diff options
| author | Bob Halley <halley@dnspython.org> | 2022-03-15 08:37:20 -0700 |
|---|---|---|
| committer | Bob Halley <halley@dnspython.org> | 2022-03-15 08:37:20 -0700 |
| commit | b1d2332687adbecc0acbb4e623124f783f859d9e (patch) | |
| tree | 5318d5ecc0dd35e0a6922380cd60f9d9caa9ad34 /tests | |
| parent | 08f8bde64e8679d5e4f0b129292461de152ba32b (diff) | |
| download | dnspython-b1d2332687adbecc0acbb4e623124f783f859d9e.tar.gz | |
black autoformatting
Diffstat (limited to 'tests')
53 files changed, 5423 insertions, 4191 deletions
diff --git a/tests/md_module.py b/tests/md_module.py index 19568bd..6ad05a8 100644 --- a/tests/md_module.py +++ b/tests/md_module.py @@ -1,4 +1,5 @@ import dns.rdtypes.nsbase + class MD(dns.rdtypes.nsbase.NSBase): """Test MD record.""" diff --git a/tests/nanonameserver.py b/tests/nanonameserver.py index 3391b32..7246e11 100644 --- a/tests/nanonameserver.py +++ b/tests/nanonameserver.py @@ -13,23 +13,26 @@ import dns.asyncquery import dns.message import dns.rcode + async def read_exactly(stream, count): """Read the specified number of bytes from stream. Keep trying until we either get the desired amount, or we hit EOF. """ - s = b'' + s = b"" while count > 0: n = await stream.receive_some(count) - if n == b'': + if n == b"": raise EOFError count = count - len(n) s = s + n return s + class ConnectionType(enum.IntEnum): UDP = 1 TCP = 2 + class Request: def __init__(self, message, wire, peer, local, connection_type): self.message = message @@ -54,6 +57,7 @@ class Request: def qtype(self): return self.question.rdtype + class Server(threading.Thread): """The nanoserver is a nameserver skeleton suitable for faking a DNS @@ -75,9 +79,16 @@ class Server(threading.Thread): called. """ - def __init__(self, address='127.0.0.1', port=0, enable_udp=True, - enable_tcp=True, use_thread=True, origin=None, - keyring=None): + def __init__( + self, + address="127.0.0.1", + port=0, + enable_udp=True, + enable_tcp=True, + use_thread=True, + origin=None, + keyring=None, + ): super().__init__() self.address = address self.port = port @@ -102,21 +113,20 @@ class Server(threading.Thread): try: while True: if self.enable_udp: - self.udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, - 0) + self.udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0) self.udp.bind((self.address, self.port)) self.udp_address = self.udp.getsockname() if self.enable_tcp: - self.tcp = socket.socket(socket.AF_INET, - socket.SOCK_STREAM, 0) - self.tcp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, - 1) + self.tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) + self.tcp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) if self.port == 0 and self.enable_udp: try: self.tcp.bind((self.address, self.udp_address[1])) except OSError as e: - if e.errno == errno.EADDRINUSE and \ - len(open_udp_sockets) < 100: + if ( + e.errno == errno.EADDRINUSE + and len(open_udp_sockets) < 100 + ): open_udp_sockets.append(self.udp) continue raise @@ -247,8 +257,7 @@ class Server(threading.Thread): while True: try: (wire, peer) = await sock.recvfrom(65535) - for wire in self.handle_wire(wire, peer, local, - ConnectionType.UDP): + for wire in self.handle_wire(wire, peer, local, ConnectionType.UDP): await sock.sendto(wire, peer) except Exception: pass @@ -261,8 +270,7 @@ class Server(threading.Thread): ldata = await read_exactly(stream, 2) (l,) = struct.unpack("!H", ldata) wire = await read_exactly(stream, l) - for wire in self.handle_wire(wire, peer, local, - ConnectionType.TCP): + for wire in self.handle_wire(wire, peer, local, ConnectionType.TCP): l = len(wire) stream_message = struct.pack("!H", l) + wire await stream.send_all(stream_message) @@ -274,8 +282,12 @@ class Server(threading.Thread): self.tcp = None # we own cleanup listener = trio.SocketListener(sock) async with trio.open_nursery() as nursery: - serve = functools.partial(trio.serve_listeners, self.serve_tcp, - [listener], handler_nursery=nursery) + serve = functools.partial( + trio.serve_listeners, + self.serve_tcp, + [listener], + handler_nursery=nursery, + ) nursery.start_soon(serve) async def main(self): @@ -292,9 +304,10 @@ class Server(threading.Thread): def run(self): if not self.use_thread: - raise RuntimeError('start() called on a use_thread=False Server') + raise RuntimeError("start() called on a use_thread=False Server") trio.run(self.main) + if __name__ == "__main__": import sys import time @@ -302,8 +315,10 @@ if __name__ == "__main__": async def trio_main(): try: with Server(port=5354, use_thread=False) as server: - print(f'Trio mode: listening on UDP: {server.udp_address}, ' + - f'TCP: {server.tcp_address}') + print( + f"Trio mode: listening on UDP: {server.udp_address}, " + + f"TCP: {server.tcp_address}" + ) async with trio.open_nursery() as nursery: nursery.start_soon(server.main) except Exception: @@ -311,11 +326,13 @@ if __name__ == "__main__": def threaded_main(): with Server(port=5354) as server: - print(f'Thread Mode: listening on UDP: {server.udp_address}, ' + - f'TCP: {server.tcp_address}') + print( + f"Thread Mode: listening on UDP: {server.udp_address}, " + + f"TCP: {server.tcp_address}" + ) time.sleep(300) - if len(sys.argv) > 1 and sys.argv[1] == 'trio': + if len(sys.argv) > 1 and sys.argv[1] == "trio": trio.run(trio_main) else: threaded_main() diff --git a/tests/stxt_module.py b/tests/stxt_module.py index 7f61235..dfe875c 100644 --- a/tests/stxt_module.py +++ b/tests/stxt_module.py @@ -1,4 +1,5 @@ import dns.rdtypes.txtbase + class STXT(dns.rdtypes.txtbase.TXTBase): """Test singleton TXT-like record""" diff --git a/tests/test_address.py b/tests/test_address.py index 1ee7022..bb689b7 100644 --- a/tests/test_address.py +++ b/tests/test_address.py @@ -8,6 +8,7 @@ import dns.exception import dns.ipv4 import dns.ipv6 + class IPv4Tests(unittest.TestCase): def test_valid(self): valid = ( @@ -23,8 +24,7 @@ class IPv4Tests(unittest.TestCase): "192.0.2.128", ) for s in valid: - self.assertEqual(dns.ipv4.inet_aton(s), - socket.inet_pton(socket.AF_INET, s)) + self.assertEqual(dns.ipv4.inet_aton(s), socket.inet_pton(socket.AF_INET, s)) def test_invalid(self): invalid = ( @@ -74,10 +74,12 @@ class IPv4Tests(unittest.TestCase): "::", ) for s in invalid: - with self.assertRaises(dns.exception.SyntaxError, - msg=f'invalid IPv4 address: "{s}"'): + with self.assertRaises( + dns.exception.SyntaxError, msg=f'invalid IPv4 address: "{s}"' + ): dns.ipv4.inet_aton(s) + class IPv6Tests(unittest.TestCase): def test_valid(self): valid = ( @@ -258,12 +260,13 @@ class IPv6Tests(unittest.TestCase): } for s in valid: - if sys.platform == 'win32' and s in win32_invalid: + if sys.platform == "win32" and s in win32_invalid: # socket.inet_pton() on win32 rejects some valid (as # far as we can tell) IPv6 addresses. Skip them. continue - self.assertEqual(dns.ipv6.inet_aton(s), - socket.inet_pton(socket.AF_INET6, s)) + self.assertEqual( + dns.ipv6.inet_aton(s), socket.inet_pton(socket.AF_INET6, s) + ) def test_invalid(self): invalid = ( @@ -576,6 +579,7 @@ class IPv6Tests(unittest.TestCase): "':10.0.0.1", ) for s in invalid: - with self.assertRaises(dns.exception.SyntaxError, - msg=f'invalid IPv6 address: "{s}"'): + with self.assertRaises( + dns.exception.SyntaxError, msg=f'invalid IPv6 address: "{s}"' + ): dns.ipv6.inet_aton(s) diff --git a/tests/test_async.py b/tests/test_async.py index ce0caa1..3c9a7e6 100644 --- a/tests/test_async.py +++ b/tests/test_async.py @@ -46,7 +46,7 @@ except Exception: # skip those if it's not there. _network_available = True try: - socket.gethostbyname('dnspython.org') + socket.gethostbyname("dnspython.org") except socket.gaierror: _network_available = False @@ -57,15 +57,17 @@ except socket.gaierror: _systemd_resolved_present = False try: _resolver = dns.resolver.Resolver() - if _resolver.nameservers == ['127.0.0.53']: + if _resolver.nameservers == ["127.0.0.53"]: _systemd_resolved_present = True except Exception: pass # Probe for IPv4 and IPv6 query_addresses = [] -for (af, address) in ((socket.AF_INET, '8.8.8.8'), - (socket.AF_INET6, '2001:4860:4860::8888')): +for (af, address) in ( + (socket.AF_INET, "8.8.8.8"), + (socket.AF_INET6, "2001:4860:4860::8888"), +): try: with socket.socket(af, socket.SOCK_DGRAM) as s: # Connecting a UDP socket is supposed to return ENETUNREACH if @@ -75,31 +77,37 @@ for (af, address) in ((socket.AF_INET, '8.8.8.8'), except Exception: pass -KNOWN_ANYCAST_DOH_RESOLVER_URLS = ['https://cloudflare-dns.com/dns-query', - 'https://dns.google/dns-query', - # 'https://dns11.quad9.net/dns-query', - ] +KNOWN_ANYCAST_DOH_RESOLVER_URLS = [ + "https://cloudflare-dns.com/dns-query", + "https://dns.google/dns-query", + # 'https://dns11.quad9.net/dns-query', +] class AsyncDetectionTests(unittest.TestCase): - sniff_result = 'asyncio' + sniff_result = "asyncio" def async_run(self, afunc): return asyncio.run(afunc()) def test_sniff(self): dns.asyncbackend._default_backend = None + async def run(): self.assertEqual(dns.asyncbackend.sniff(), self.sniff_result) + self.async_run(run) def test_get_default_backend(self): dns.asyncbackend._default_backend = None + async def run(): backend = dns.asyncbackend.get_default_backend() self.assertEqual(backend.name(), self.sniff_result) + self.async_run(run) + class NoSniffioAsyncDetectionTests(AsyncDetectionTests): expect_raise = False @@ -112,10 +120,13 @@ class NoSniffioAsyncDetectionTests(AsyncDetectionTests): def test_sniff(self): dns.asyncbackend._default_backend = None if self.expect_raise: + async def abad(): dns.asyncbackend.sniff() + def bad(): self.async_run(abad) + self.assertRaises(dns.asyncbackend.AsyncLibraryNotFoundError, bad) else: super().test_sniff() @@ -123,10 +134,13 @@ class NoSniffioAsyncDetectionTests(AsyncDetectionTests): def test_get_default_backend(self): dns.asyncbackend._default_backend = None if self.expect_raise: + async def abad(): dns.asyncbackend.get_default_backend() + def bad(): self.async_run(abad) + self.assertRaises(dns.asyncbackend.AsyncLibraryNotFoundError, bad) else: super().test_get_default_backend() @@ -135,13 +149,16 @@ class NoSniffioAsyncDetectionTests(AsyncDetectionTests): class MiscBackend(unittest.TestCase): def test_sniff_without_run_loop(self): dns.asyncbackend._default_backend = None + def bad(): dns.asyncbackend.sniff() + self.assertRaises(dns.asyncbackend.AsyncLibraryNotFoundError, bad) def test_bogus_backend(self): def bad(): - dns.asyncbackend.get_backend('bogus') + dns.asyncbackend.get_backend("bogus") + self.assertRaises(NotImplementedError, bad) @@ -151,256 +168,297 @@ class MiscQuery(unittest.TestCase): self.assertEqual(t, None) t = dns.asyncquery._source_tuple(socket.AF_INET6, None, 0) self.assertEqual(t, None) - t = dns.asyncquery._source_tuple(socket.AF_INET, '1.2.3.4', 53) - self.assertEqual(t, ('1.2.3.4', 53)) - t = dns.asyncquery._source_tuple(socket.AF_INET6, '1::2', 53) - self.assertEqual(t, ('1::2', 53)) + t = dns.asyncquery._source_tuple(socket.AF_INET, "1.2.3.4", 53) + self.assertEqual(t, ("1.2.3.4", 53)) + t = dns.asyncquery._source_tuple(socket.AF_INET6, "1::2", 53) + self.assertEqual(t, ("1::2", 53)) t = dns.asyncquery._source_tuple(socket.AF_INET, None, 53) - self.assertEqual(t, ('0.0.0.0', 53)) + self.assertEqual(t, ("0.0.0.0", 53)) t = dns.asyncquery._source_tuple(socket.AF_INET6, None, 53) - self.assertEqual(t, ('::', 53)) + self.assertEqual(t, ("::", 53)) @unittest.skipIf(not _network_available, "Internet not reachable") class AsyncTests(unittest.TestCase): - connect_udp = sys.platform == 'win32' + connect_udp = sys.platform == "win32" def setUp(self): - self.backend = dns.asyncbackend.set_default_backend('asyncio') + self.backend = dns.asyncbackend.set_default_backend("asyncio") def async_run(self, afunc): return asyncio.run(afunc()) def testResolve(self): async def run(): - answer = await dns.asyncresolver.resolve('dns.google.', 'A') + answer = await dns.asyncresolver.resolve("dns.google.", "A") return set([rdata.address for rdata in answer]) + seen = self.async_run(run) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) def testResolveAddress(self): async def run(): - return await dns.asyncresolver.resolve_address('8.8.8.8') + return await dns.asyncresolver.resolve_address("8.8.8.8") + answer = self.async_run(run) - dnsgoogle = dns.name.from_text('dns.google.') + dnsgoogle = dns.name.from_text("dns.google.") self.assertEqual(answer[0].target, dnsgoogle) def testCanonicalNameNoCNAME(self): - cname = dns.name.from_text('www.google.com') + cname = dns.name.from_text("www.google.com") + async def run(): - return await dns.asyncresolver.canonical_name('www.google.com') + return await dns.asyncresolver.canonical_name("www.google.com") + self.assertEqual(self.async_run(run), cname) def testCanonicalNameCNAME(self): - name = dns.name.from_text('www.dnspython.org') - cname = dns.name.from_text('dmfrjf4ips8xa.cloudfront.net') + name = dns.name.from_text("www.dnspython.org") + cname = dns.name.from_text("dmfrjf4ips8xa.cloudfront.net") + async def run(): return await dns.asyncresolver.canonical_name(name) + self.assertEqual(self.async_run(run), cname) @unittest.skipIf(_systemd_resolved_present, "systemd-resolved in use") def testCanonicalNameDangling(self): - name = dns.name.from_text('dangling-cname.dnspython.org') - cname = dns.name.from_text('dangling-target.dnspython.org') + name = dns.name.from_text("dangling-cname.dnspython.org") + cname = dns.name.from_text("dangling-target.dnspython.org") + async def run(): return await dns.asyncresolver.canonical_name(name) - self.assertEqual(self.async_run(run), cname) + self.assertEqual(self.async_run(run), cname) def testZoneForName1(self): async def run(): - name = dns.name.from_text('www.dnspython.org.') + name = dns.name.from_text("www.dnspython.org.") return await dns.asyncresolver.zone_for_name(name) - ezname = dns.name.from_text('dnspython.org.') + + ezname = dns.name.from_text("dnspython.org.") zname = self.async_run(run) self.assertEqual(zname, ezname) def testZoneForName2(self): async def run(): - name = dns.name.from_text('a.b.www.dnspython.org.') + name = dns.name.from_text("a.b.www.dnspython.org.") return await dns.asyncresolver.zone_for_name(name) - ezname = dns.name.from_text('dnspython.org.') + + ezname = dns.name.from_text("dnspython.org.") zname = self.async_run(run) self.assertEqual(zname, ezname) def testZoneForName3(self): async def run(): - name = dns.name.from_text('dnspython.org.') + name = dns.name.from_text("dnspython.org.") return await dns.asyncresolver.zone_for_name(name) - ezname = dns.name.from_text('dnspython.org.') + + ezname = dns.name.from_text("dnspython.org.") zname = self.async_run(run) self.assertEqual(zname, ezname) def testZoneForName4(self): def bad(): - name = dns.name.from_text('dnspython.org', None) + name = dns.name.from_text("dnspython.org", None) + async def run(): return await dns.asyncresolver.zone_for_name(name) + self.async_run(run) + self.assertRaises(dns.resolver.NotAbsolute, bad) def testQueryUDP(self): for address in query_addresses: - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") + async def run(): q = dns.message.make_query(qname, dns.rdatatype.A) return await dns.asyncquery.udp(q, address, timeout=2) + response = self.async_run(run) - rrs = response.get_rrset(response.answer, qname, - dns.rdataclass.IN, dns.rdatatype.A) + rrs = response.get_rrset( + response.answer, qname, dns.rdataclass.IN, dns.rdatatype.A + ) self.assertTrue(rrs is not None) seen = set([rdata.address for rdata in rrs]) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) def testQueryUDPWithSocket(self): for address in query_addresses: - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") + async def run(): if self.connect_udp: - dtuple=(address, 53) + dtuple = (address, 53) else: - dtuple=None + dtuple = None async with await self.backend.make_socket( - dns.inet.af_for_address(address), - socket.SOCK_DGRAM, 0, None, dtuple) as s: + dns.inet.af_for_address(address), socket.SOCK_DGRAM, 0, None, dtuple + ) as s: q = dns.message.make_query(qname, dns.rdatatype.A) - return await dns.asyncquery.udp(q, address, sock=s, - timeout=2) + return await dns.asyncquery.udp(q, address, sock=s, timeout=2) + response = self.async_run(run) - rrs = response.get_rrset(response.answer, qname, - dns.rdataclass.IN, dns.rdatatype.A) + rrs = response.get_rrset( + response.answer, qname, dns.rdataclass.IN, dns.rdatatype.A + ) self.assertTrue(rrs is not None) seen = set([rdata.address for rdata in rrs]) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) def testQueryTCP(self): for address in query_addresses: - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") + async def run(): q = dns.message.make_query(qname, dns.rdatatype.A) return await dns.asyncquery.tcp(q, address, timeout=2) + response = self.async_run(run) - rrs = response.get_rrset(response.answer, qname, - dns.rdataclass.IN, dns.rdatatype.A) + rrs = response.get_rrset( + response.answer, qname, dns.rdataclass.IN, dns.rdatatype.A + ) self.assertTrue(rrs is not None) seen = set([rdata.address for rdata in rrs]) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) def testQueryTCPWithSocket(self): for address in query_addresses: - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") + async def run(): async with await self.backend.make_socket( - dns.inet.af_for_address(address), - socket.SOCK_STREAM, 0, - None, - (address, 53), 2) as s: + dns.inet.af_for_address(address), + socket.SOCK_STREAM, + 0, + None, + (address, 53), + 2, + ) as s: # for basic coverage await s.getsockname() q = dns.message.make_query(qname, dns.rdatatype.A) - return await dns.asyncquery.tcp(q, address, sock=s, - timeout=2) + return await dns.asyncquery.tcp(q, address, sock=s, timeout=2) + response = self.async_run(run) - rrs = response.get_rrset(response.answer, qname, - dns.rdataclass.IN, dns.rdatatype.A) + rrs = response.get_rrset( + response.answer, qname, dns.rdataclass.IN, dns.rdatatype.A + ) self.assertTrue(rrs is not None) seen = set([rdata.address for rdata in rrs]) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) @unittest.skipIf(not _ssl_available, "SSL not available") def testQueryTLS(self): for address in query_addresses: - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") + async def run(): q = dns.message.make_query(qname, dns.rdatatype.A) return await dns.asyncquery.tls(q, address, timeout=2) + response = self.async_run(run) - rrs = response.get_rrset(response.answer, qname, - dns.rdataclass.IN, dns.rdatatype.A) + rrs = response.get_rrset( + response.answer, qname, dns.rdataclass.IN, dns.rdatatype.A + ) self.assertTrue(rrs is not None) seen = set([rdata.address for rdata in rrs]) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) @unittest.skipIf(not _ssl_available, "SSL not available") def testQueryTLSWithSocket(self): for address in query_addresses: - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") + async def run(): ssl_context = ssl.create_default_context() ssl_context.check_hostname = False async with await self.backend.make_socket( - dns.inet.af_for_address(address), - socket.SOCK_STREAM, 0, - None, - (address, 853), 2, - ssl_context, None) as s: + dns.inet.af_for_address(address), + socket.SOCK_STREAM, + 0, + None, + (address, 853), + 2, + ssl_context, + None, + ) as s: # for basic coverage await s.getsockname() q = dns.message.make_query(qname, dns.rdatatype.A) - return await dns.asyncquery.tls(q, '8.8.8.8', sock=s, - timeout=2) + return await dns.asyncquery.tls(q, "8.8.8.8", sock=s, timeout=2) + response = self.async_run(run) - rrs = response.get_rrset(response.answer, qname, - dns.rdataclass.IN, dns.rdatatype.A) + rrs = response.get_rrset( + response.answer, qname, dns.rdataclass.IN, dns.rdatatype.A + ) self.assertTrue(rrs is not None) seen = set([rdata.address for rdata in rrs]) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) def testQueryUDPFallback(self): for address in query_addresses: - qname = dns.name.from_text('.') + qname = dns.name.from_text(".") + async def run(): q = dns.message.make_query(qname, dns.rdatatype.DNSKEY) - return await dns.asyncquery.udp_with_fallback(q, address, - timeout=2) + return await dns.asyncquery.udp_with_fallback(q, address, timeout=2) + (_, tcp) = self.async_run(run) self.assertTrue(tcp) def testQueryUDPFallbackNoFallback(self): for address in query_addresses: - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") + async def run(): q = dns.message.make_query(qname, dns.rdatatype.A) - return await dns.asyncquery.udp_with_fallback(q, address, - timeout=2) + return await dns.asyncquery.udp_with_fallback(q, address, timeout=2) + (_, tcp) = self.async_run(run) self.assertFalse(tcp) def testUDPReceiveQuery(self): if self.connect_udp: - self.skipTest('test needs connectionless sockets') + self.skipTest("test needs connectionless sockets") + async def run(): async with await self.backend.make_socket( - socket.AF_INET, socket.SOCK_DGRAM, - source=('127.0.0.1', 0)) as listener: + socket.AF_INET, socket.SOCK_DGRAM, source=("127.0.0.1", 0) + ) as listener: listener_address = await listener.getsockname() async with await self.backend.make_socket( - socket.AF_INET, socket.SOCK_DGRAM, - source=('127.0.0.1', 0)) as sender: + socket.AF_INET, socket.SOCK_DGRAM, source=("127.0.0.1", 0) + ) as sender: sender_address = await sender.getsockname() - q = dns.message.make_query('dns.google', dns.rdatatype.A) + q = dns.message.make_query("dns.google", dns.rdatatype.A) await dns.asyncquery.send_udp(sender, q, listener_address) expiration = time.time() + 2 (_, _, recv_address) = await dns.asyncquery.receive_udp( - listener, expiration=expiration) + listener, expiration=expiration + ) return (sender_address, recv_address) + (sender_address, recv_address) = self.async_run(run) self.assertEqual(sender_address, recv_address) def testUDPReceiveTimeout(self): if self.connect_udp: - self.skipTest('test needs connectionless sockets') + self.skipTest("test needs connectionless sockets") + async def arun(): - async with await self.backend.make_socket(socket.AF_INET, - socket.SOCK_DGRAM, 0, - ('127.0.0.1', 0)) as s: + async with await self.backend.make_socket( + socket.AF_INET, socket.SOCK_DGRAM, 0, ("127.0.0.1", 0) + ) as s: try: # for basic coverage await s.getpeername() @@ -408,62 +466,69 @@ class AsyncTests(unittest.TestCase): # we expect failure as we haven't connected the socket pass await s.recvfrom(1000, 0.05) + def run(): self.async_run(arun) + self.assertRaises(dns.exception.Timeout, run) @unittest.skipIf(not dns.query._have_httpx, "httpx not available") def testDOHGetRequest(self): - if self.backend.name() == 'curio': - self.skipTest('anyio dropped curio support') + if self.backend.name() == "curio": + self.skipTest("anyio dropped curio support") + async def run(): nameserver_url = random.choice(KNOWN_ANYCAST_DOH_RESOLVER_URLS) - q = dns.message.make_query('example.com.', dns.rdatatype.A) - r = await dns.asyncquery.https(q, nameserver_url, post=False, - timeout=4) + q = dns.message.make_query("example.com.", dns.rdatatype.A) + r = await dns.asyncquery.https(q, nameserver_url, post=False, timeout=4) self.assertTrue(q.is_response(r)) + self.async_run(run) @unittest.skipIf(not dns.query._have_httpx, "httpx not available") def testDOHGetRequestHttp1(self): - if self.backend.name() == 'curio': - self.skipTest('anyio dropped curio support') + if self.backend.name() == "curio": + self.skipTest("anyio dropped curio support") + async def run(): saved_have_http2 = dns.query._have_http2 try: dns.query._have_http2 = False nameserver_url = random.choice(KNOWN_ANYCAST_DOH_RESOLVER_URLS) - q = dns.message.make_query('example.com.', dns.rdatatype.A) - r = await dns.asyncquery.https(q, nameserver_url, post=False, - timeout=4) + q = dns.message.make_query("example.com.", dns.rdatatype.A) + r = await dns.asyncquery.https(q, nameserver_url, post=False, timeout=4) self.assertTrue(q.is_response(r)) finally: dns.query._have_http2 = saved_have_http2 + self.async_run(run) @unittest.skipIf(not dns.query._have_httpx, "httpx not available") def testDOHPostRequest(self): - if self.backend.name() == 'curio': - self.skipTest('anyio dropped curio support') + if self.backend.name() == "curio": + self.skipTest("anyio dropped curio support") + async def run(): nameserver_url = random.choice(KNOWN_ANYCAST_DOH_RESOLVER_URLS) - q = dns.message.make_query('example.com.', dns.rdatatype.A) - r = await dns.asyncquery.https(q, nameserver_url, post=True, - timeout=4) + q = dns.message.make_query("example.com.", dns.rdatatype.A) + r = await dns.asyncquery.https(q, nameserver_url, post=True, timeout=4) self.assertTrue(q.is_response(r)) + self.async_run(run) @unittest.skipIf(not dns.query._have_httpx, "httpx not available") def testResolverDOH(self): - if self.backend.name() == 'curio': - self.skipTest('anyio dropped curio support') + if self.backend.name() == "curio": + self.skipTest("anyio dropped curio support") + async def run(): res = dns.asyncresolver.Resolver(configure=False) - res.nameservers = ['https://dns.google/dns-query'] - answer = await res.resolve('dns.google', 'A', backend=self.backend) + res.nameservers = ["https://dns.google/dns-query"] + answer = await res.resolve("dns.google", "A", backend=self.backend) seen = set([rdata.address for rdata in answer]) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) + self.async_run(run) def testSleep(self): @@ -472,29 +537,35 @@ class AsyncTests(unittest.TestCase): await self.backend.sleep(0.1) after = time.time() self.assertTrue(after - before >= 0.1) + self.async_run(run) + try: import trio import sniffio class TrioAsyncDetectionTests(AsyncDetectionTests): - sniff_result = 'trio' + sniff_result = "trio" + def async_run(self, afunc): return trio.run(afunc) class TrioNoSniffioAsyncDetectionTests(NoSniffioAsyncDetectionTests): expect_raise = True + def async_run(self, afunc): return trio.run(afunc) class TrioAsyncTests(AsyncTests): connect_udp = False + def setUp(self): - self.backend = dns.asyncbackend.set_default_backend('trio') + self.backend = dns.asyncbackend.set_default_backend("trio") def async_run(self, afunc): return trio.run(afunc) + except ImportError: pass @@ -503,21 +574,25 @@ try: import sniffio class CurioAsyncDetectionTests(AsyncDetectionTests): - sniff_result = 'curio' + sniff_result = "curio" + def async_run(self, afunc): return curio.run(afunc) class CurioNoSniffioAsyncDetectionTests(NoSniffioAsyncDetectionTests): expect_raise = True + def async_run(self, afunc): return curio.run(afunc) class CurioAsyncTests(AsyncTests): connect_udp = False + def setUp(self): - self.backend = dns.asyncbackend.set_default_backend('curio') + self.backend = dns.asyncbackend.set_default_backend("curio") def async_run(self, afunc): return curio.run(afunc) + except ImportError: pass diff --git a/tests/test_bugs.py b/tests/test_bugs.py index 3080e50..ac76b8d 100644 --- a/tests/test_bugs.py +++ b/tests/test_bugs.py @@ -28,69 +28,72 @@ import dns.ttl class BugsTestCase(unittest.TestCase): - def test_float_LOC(self): - rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.LOC, - u"30 30 0.000 N 100 30 0.000 W 10.00m 20m 2000m 20m") + rdata = dns.rdata.from_text( + dns.rdataclass.IN, + dns.rdatatype.LOC, + "30 30 0.000 N 100 30 0.000 W 10.00m 20m 2000m 20m", + ) self.assertEqual(rdata.float_latitude, 30.5) self.assertEqual(rdata.float_longitude, -100.5) def test_SOA_BIND8_TTL(self): - rdata1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, - u"a b 100 1s 1m 1h 1d") - rdata2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, - u"a b 100 1 60 3600 86400") + rdata1 = dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SOA, "a b 100 1s 1m 1h 1d" + ) + rdata2 = dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SOA, "a b 100 1 60 3600 86400" + ) self.assertEqual(rdata1, rdata2) def test_empty_NSEC3_window(self): - rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NSEC3, - u"1 0 100 ABCD SCBCQHKU35969L2A68P3AD59LHF30715") + rdata = dns.rdata.from_text( + dns.rdataclass.IN, + dns.rdatatype.NSEC3, + "1 0 100 ABCD SCBCQHKU35969L2A68P3AD59LHF30715", + ) self.assertEqual(rdata.windows, ()) def test_zero_size_APL(self): - rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.APL, - "") - rdata2 = dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.APL, - "", 0, 0) + rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.APL, "") + rdata2 = dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.APL, "", 0, 0) self.assertEqual(rdata, rdata2) def test_CAA_from_wire(self): - rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CAA, - '0 issue "ca.example.net"') + rdata = dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.CAA, '0 issue "ca.example.net"' + ) f = BytesIO() rdata.to_wire(f) wire = f.getvalue() rdlen = len(wire) wire += b"trailing garbage" - rdata2 = dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.CAA, - wire, 0, rdlen) + rdata2 = dns.rdata.from_wire( + dns.rdataclass.IN, dns.rdatatype.CAA, wire, 0, rdlen + ) self.assertEqual(rdata, rdata2) def test_trailing_zero_APL(self): in4 = "!1:127.0.0.0/1" rd4 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.APL, in4) out4 = rd4.to_digestable(dns.name.from_text("test")) - text4 = binascii.hexlify(out4).decode('ascii') - self.assertEqual(text4, '000101817f') + text4 = binascii.hexlify(out4).decode("ascii") + self.assertEqual(text4, "000101817f") in6 = "!2:::1000/1" rd6 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.APL, in6) out6 = rd6.to_digestable(dns.name.from_text("test")) - text6 = binascii.hexlify(out6).decode('ascii') - self.assertEqual(text6, '0002018f000000000000000000000000000010') + text6 = binascii.hexlify(out6).decode("ascii") + self.assertEqual(text6, "0002018f000000000000000000000000000010") def test_TXT_conversions(self): - t1 = dns.rdtypes.ANY.TXT.TXT(dns.rdataclass.IN, dns.rdatatype.TXT, - [b'foo']) - t2 = dns.rdtypes.ANY.TXT.TXT(dns.rdataclass.IN, dns.rdatatype.TXT, - b'foo') - t3 = dns.rdtypes.ANY.TXT.TXT(dns.rdataclass.IN, dns.rdatatype.TXT, - 'foo') - t4 = dns.rdtypes.ANY.TXT.TXT(dns.rdataclass.IN, dns.rdatatype.TXT, - ['foo']) + t1 = dns.rdtypes.ANY.TXT.TXT(dns.rdataclass.IN, dns.rdatatype.TXT, [b"foo"]) + t2 = dns.rdtypes.ANY.TXT.TXT(dns.rdataclass.IN, dns.rdatatype.TXT, b"foo") + t3 = dns.rdtypes.ANY.TXT.TXT(dns.rdataclass.IN, dns.rdatatype.TXT, "foo") + t4 = dns.rdtypes.ANY.TXT.TXT(dns.rdataclass.IN, dns.rdatatype.TXT, ["foo"]) self.assertEqual(t1, t2) self.assertEqual(t1, t2) self.assertEqual(t1, t4) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/tests/test_constants.py b/tests/test_constants.py index 0c38c28..bf0d970 100644 --- a/tests/test_constants.py +++ b/tests/test_constants.py @@ -15,10 +15,10 @@ import tests.util class ConstantsTestCase(unittest.TestCase): - def test_dnssec_constants(self): - tests.util.check_enum_exports(dns.dnssec, self.assertEqual, - only={dns.dnssec.Algorithm}) + tests.util.check_enum_exports( + dns.dnssec, self.assertEqual, only={dns.dnssec.Algorithm} + ) tests.util.check_enum_exports(dns.rdtypes.dnskeybase, self.assertEqual) def test_flags_constants(self): @@ -35,5 +35,6 @@ class ConstantsTestCase(unittest.TestCase): tests.util.check_enum_exports(dns.rdatatype, self.assertEqual) def test_edns_constants(self): - tests.util.check_enum_exports(dns.edns, self.assertEqual, - only={dns.edns.OptionType}) + tests.util.check_enum_exports( + dns.edns, self.assertEqual, only={dns.edns.OptionType} + ) diff --git a/tests/test_dnssec.py b/tests/test_dnssec.py index e818992..fbc83f9 100644 --- a/tests/test_dnssec.py +++ b/tests/test_dnssec.py @@ -30,246 +30,419 @@ import dns.rrset # pylint: disable=line-too-long -abs_dnspython_org = dns.name.from_text('dnspython.org') +abs_dnspython_org = dns.name.from_text("dnspython.org") abs_keys = { abs_dnspython_org: dns.rrset.from_text( - 'dnspython.org.', 3600, 'IN', 'DNSKEY', - '257 3 5 AwEAAenVTr9L1OMlL1/N2ta0Qj9LLLnnmFWIr1dJoAsWM9BQfsbV7kFZ XbAkER/FY9Ji2o7cELxBwAsVBuWn6IUUAJXLH74YbC1anY0lifjgt29z SwDzuB7zmC7yVYZzUunBulVW4zT0tg1aePbpVL2EtTL8VzREqbJbE25R KuQYHZtFwG8S4iBxJUmT2Bbd0921LLxSQgVoFXlQx/gFV2+UERXcJ5ce iX6A6wc02M/pdg/YbJd2rBa0MYL3/Fz/Xltre0tqsImZGxzi6YtYDs45 NC8gH+44egz82e2DATCVM1ICPmRDjXYTLldQiWA2ZXIWnK0iitl5ue24 7EsWJefrIhE=', - '256 3 5 AwEAAdSSghOGjU33IQZgwZM2Hh771VGXX05olJK49FxpSyuEAjDBXY58 LGU9R2Zgeecnk/b9EAhFu/vCV9oECtiTCvwuVAkt9YEweqYDluQInmgP NGMJCKdSLlnX93DkjDw8rMYv5dqXCuSGPlKChfTJOLQxIAxGloS7lL+c 0CTZydAF' + "dnspython.org.", + 3600, + "IN", + "DNSKEY", + "257 3 5 AwEAAenVTr9L1OMlL1/N2ta0Qj9LLLnnmFWIr1dJoAsWM9BQfsbV7kFZ XbAkER/FY9Ji2o7cELxBwAsVBuWn6IUUAJXLH74YbC1anY0lifjgt29z SwDzuB7zmC7yVYZzUunBulVW4zT0tg1aePbpVL2EtTL8VzREqbJbE25R KuQYHZtFwG8S4iBxJUmT2Bbd0921LLxSQgVoFXlQx/gFV2+UERXcJ5ce iX6A6wc02M/pdg/YbJd2rBa0MYL3/Fz/Xltre0tqsImZGxzi6YtYDs45 NC8gH+44egz82e2DATCVM1ICPmRDjXYTLldQiWA2ZXIWnK0iitl5ue24 7EsWJefrIhE=", + "256 3 5 AwEAAdSSghOGjU33IQZgwZM2Hh771VGXX05olJK49FxpSyuEAjDBXY58 LGU9R2Zgeecnk/b9EAhFu/vCV9oECtiTCvwuVAkt9YEweqYDluQInmgP NGMJCKdSLlnX93DkjDw8rMYv5dqXCuSGPlKChfTJOLQxIAxGloS7lL+c 0CTZydAF", ) } abs_keys_duplicate_keytag = { abs_dnspython_org: dns.rrset.from_text( - 'dnspython.org.', 3600, 'IN', 'DNSKEY', - '257 3 5 AwEAAenVTr9L1OMlL1/N2ta0Qj9LLLnnmFWIr1dJoAsWM9BQfsbV7kFZ XbAkER/FY9Ji2o7cELxBwAsVBuWn6IUUAJXLH74YbC1anY0lifjgt29z SwDzuB7zmC7yVYZzUunBulVW4zT0tg1aePbpVL2EtTL8VzREqbJbE25R KuQYHZtFwG8S4iBxJUmT2Bbd0921LLxSQgVoFXlQx/gFV2+UERXcJ5ce iX6A6wc02M/pdg/YbJd2rBa0MYL3/Fz/Xltre0tqsImZGxzi6YtYDs45 NC8gH+44egz82e2DATCVM1ICPmRDjXYTLldQiWA2ZXIWnK0iitl5ue24 7EsWJefrIhE=', - '256 3 5 AwEAAdSSg++++THIS/IS/NOT/THE/CORRECT/KEY++++++++++++++++ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ AaOSydAF', - '256 3 5 AwEAAdSSghOGjU33IQZgwZM2Hh771VGXX05olJK49FxpSyuEAjDBXY58 LGU9R2Zgeecnk/b9EAhFu/vCV9oECtiTCvwuVAkt9YEweqYDluQInmgP NGMJCKdSLlnX93DkjDw8rMYv5dqXCuSGPlKChfTJOLQxIAxGloS7lL+c 0CTZydAF' + "dnspython.org.", + 3600, + "IN", + "DNSKEY", + "257 3 5 AwEAAenVTr9L1OMlL1/N2ta0Qj9LLLnnmFWIr1dJoAsWM9BQfsbV7kFZ XbAkER/FY9Ji2o7cELxBwAsVBuWn6IUUAJXLH74YbC1anY0lifjgt29z SwDzuB7zmC7yVYZzUunBulVW4zT0tg1aePbpVL2EtTL8VzREqbJbE25R KuQYHZtFwG8S4iBxJUmT2Bbd0921LLxSQgVoFXlQx/gFV2+UERXcJ5ce iX6A6wc02M/pdg/YbJd2rBa0MYL3/Fz/Xltre0tqsImZGxzi6YtYDs45 NC8gH+44egz82e2DATCVM1ICPmRDjXYTLldQiWA2ZXIWnK0iitl5ue24 7EsWJefrIhE=", + "256 3 5 AwEAAdSSg++++THIS/IS/NOT/THE/CORRECT/KEY++++++++++++++++ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ AaOSydAF", + "256 3 5 AwEAAdSSghOGjU33IQZgwZM2Hh771VGXX05olJK49FxpSyuEAjDBXY58 LGU9R2Zgeecnk/b9EAhFu/vCV9oECtiTCvwuVAkt9YEweqYDluQInmgP NGMJCKdSLlnX93DkjDw8rMYv5dqXCuSGPlKChfTJOLQxIAxGloS7lL+c 0CTZydAF", ) } rel_keys = { dns.name.empty: dns.rrset.from_text( - '@', 3600, 'IN', 'DNSKEY', - '257 3 5 AwEAAenVTr9L1OMlL1/N2ta0Qj9LLLnnmFWIr1dJoAsWM9BQfsbV7kFZ XbAkER/FY9Ji2o7cELxBwAsVBuWn6IUUAJXLH74YbC1anY0lifjgt29z SwDzuB7zmC7yVYZzUunBulVW4zT0tg1aePbpVL2EtTL8VzREqbJbE25R KuQYHZtFwG8S4iBxJUmT2Bbd0921LLxSQgVoFXlQx/gFV2+UERXcJ5ce iX6A6wc02M/pdg/YbJd2rBa0MYL3/Fz/Xltre0tqsImZGxzi6YtYDs45 NC8gH+44egz82e2DATCVM1ICPmRDjXYTLldQiWA2ZXIWnK0iitl5ue24 7EsWJefrIhE=', - '256 3 5 AwEAAdSSghOGjU33IQZgwZM2Hh771VGXX05olJK49FxpSyuEAjDBXY58 LGU9R2Zgeecnk/b9EAhFu/vCV9oECtiTCvwuVAkt9YEweqYDluQInmgP NGMJCKdSLlnX93DkjDw8rMYv5dqXCuSGPlKChfTJOLQxIAxGloS7lL+c 0CTZydAF' + "@", + 3600, + "IN", + "DNSKEY", + "257 3 5 AwEAAenVTr9L1OMlL1/N2ta0Qj9LLLnnmFWIr1dJoAsWM9BQfsbV7kFZ XbAkER/FY9Ji2o7cELxBwAsVBuWn6IUUAJXLH74YbC1anY0lifjgt29z SwDzuB7zmC7yVYZzUunBulVW4zT0tg1aePbpVL2EtTL8VzREqbJbE25R KuQYHZtFwG8S4iBxJUmT2Bbd0921LLxSQgVoFXlQx/gFV2+UERXcJ5ce iX6A6wc02M/pdg/YbJd2rBa0MYL3/Fz/Xltre0tqsImZGxzi6YtYDs45 NC8gH+44egz82e2DATCVM1ICPmRDjXYTLldQiWA2ZXIWnK0iitl5ue24 7EsWJefrIhE=", + "256 3 5 AwEAAdSSghOGjU33IQZgwZM2Hh771VGXX05olJK49FxpSyuEAjDBXY58 LGU9R2Zgeecnk/b9EAhFu/vCV9oECtiTCvwuVAkt9YEweqYDluQInmgP NGMJCKdSLlnX93DkjDw8rMYv5dqXCuSGPlKChfTJOLQxIAxGloS7lL+c 0CTZydAF", ) } when = 1290250287 -abs_soa = dns.rrset.from_text('dnspython.org.', 3600, 'IN', 'SOA', - 'howl.dnspython.org. hostmaster.dnspython.org. 2010020047 3600 1800 604800 3600') - -abs_other_soa = dns.rrset.from_text('dnspython.org.', 3600, 'IN', 'SOA', - 'foo.dnspython.org. hostmaster.dnspython.org. 2010020047 3600 1800 604800 3600') - -abs_soa_rrsig = dns.rrset.from_text('dnspython.org.', 3600, 'IN', 'RRSIG', - 'SOA 5 2 3600 20101127004331 20101119213831 61695 dnspython.org. sDUlltRlFTQw5ITFxOXW3TgmrHeMeNpdqcZ4EXxM9FHhIlte6V9YCnDw t6dvM9jAXdIEi03l9H/RAd9xNNW6gvGMHsBGzpvvqFQxIBR2PoiZA1mX /SWHZFdbt4xjYTtXqpyYvrMK0Dt7bUYPadyhPFCJ1B+I8Zi7B5WJEOd0 8vs=') - -rel_soa = dns.rrset.from_text('@', 3600, 'IN', 'SOA', - 'howl hostmaster 2010020047 3600 1800 604800 3600') - -rel_other_soa = dns.rrset.from_text('@', 3600, 'IN', 'SOA', - 'foo hostmaster 2010020047 3600 1800 604800 3600') - -rel_soa_rrsig = dns.rrset.from_text('@', 3600, 'IN', 'RRSIG', - 'SOA 5 2 3600 20101127004331 20101119213831 61695 @ sDUlltRlFTQw5ITFxOXW3TgmrHeMeNpdqcZ4EXxM9FHhIlte6V9YCnDw t6dvM9jAXdIEi03l9H/RAd9xNNW6gvGMHsBGzpvvqFQxIBR2PoiZA1mX /SWHZFdbt4xjYTtXqpyYvrMK0Dt7bUYPadyhPFCJ1B+I8Zi7B5WJEOd0 8vs=') - -sep_key = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.DNSKEY, - '257 3 5 AwEAAenVTr9L1OMlL1/N2ta0Qj9LLLnnmFWIr1dJoAsWM9BQfsbV7kFZ XbAkER/FY9Ji2o7cELxBwAsVBuWn6IUUAJXLH74YbC1anY0lifjgt29z SwDzuB7zmC7yVYZzUunBulVW4zT0tg1aePbpVL2EtTL8VzREqbJbE25R KuQYHZtFwG8S4iBxJUmT2Bbd0921LLxSQgVoFXlQx/gFV2+UERXcJ5ce iX6A6wc02M/pdg/YbJd2rBa0MYL3/Fz/Xltre0tqsImZGxzi6YtYDs45 NC8gH+44egz82e2DATCVM1ICPmRDjXYTLldQiWA2ZXIWnK0iitl5ue24 7EsWJefrIhE=') - -good_ds = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.DS, - '57349 5 2 53A79A3E7488AB44FFC56B2D1109F0699D1796DD977E72108B841F96 E47D7013') +abs_soa = dns.rrset.from_text( + "dnspython.org.", + 3600, + "IN", + "SOA", + "howl.dnspython.org. hostmaster.dnspython.org. 2010020047 3600 1800 604800 3600", +) + +abs_other_soa = dns.rrset.from_text( + "dnspython.org.", + 3600, + "IN", + "SOA", + "foo.dnspython.org. hostmaster.dnspython.org. 2010020047 3600 1800 604800 3600", +) + +abs_soa_rrsig = dns.rrset.from_text( + "dnspython.org.", + 3600, + "IN", + "RRSIG", + "SOA 5 2 3600 20101127004331 20101119213831 61695 dnspython.org. sDUlltRlFTQw5ITFxOXW3TgmrHeMeNpdqcZ4EXxM9FHhIlte6V9YCnDw t6dvM9jAXdIEi03l9H/RAd9xNNW6gvGMHsBGzpvvqFQxIBR2PoiZA1mX /SWHZFdbt4xjYTtXqpyYvrMK0Dt7bUYPadyhPFCJ1B+I8Zi7B5WJEOd0 8vs=", +) + +rel_soa = dns.rrset.from_text( + "@", 3600, "IN", "SOA", "howl hostmaster 2010020047 3600 1800 604800 3600" +) + +rel_other_soa = dns.rrset.from_text( + "@", 3600, "IN", "SOA", "foo hostmaster 2010020047 3600 1800 604800 3600" +) + +rel_soa_rrsig = dns.rrset.from_text( + "@", + 3600, + "IN", + "RRSIG", + "SOA 5 2 3600 20101127004331 20101119213831 61695 @ sDUlltRlFTQw5ITFxOXW3TgmrHeMeNpdqcZ4EXxM9FHhIlte6V9YCnDw t6dvM9jAXdIEi03l9H/RAd9xNNW6gvGMHsBGzpvvqFQxIBR2PoiZA1mX /SWHZFdbt4xjYTtXqpyYvrMK0Dt7bUYPadyhPFCJ1B+I8Zi7B5WJEOd0 8vs=", +) + +sep_key = dns.rdata.from_text( + dns.rdataclass.IN, + dns.rdatatype.DNSKEY, + "257 3 5 AwEAAenVTr9L1OMlL1/N2ta0Qj9LLLnnmFWIr1dJoAsWM9BQfsbV7kFZ XbAkER/FY9Ji2o7cELxBwAsVBuWn6IUUAJXLH74YbC1anY0lifjgt29z SwDzuB7zmC7yVYZzUunBulVW4zT0tg1aePbpVL2EtTL8VzREqbJbE25R KuQYHZtFwG8S4iBxJUmT2Bbd0921LLxSQgVoFXlQx/gFV2+UERXcJ5ce iX6A6wc02M/pdg/YbJd2rBa0MYL3/Fz/Xltre0tqsImZGxzi6YtYDs45 NC8gH+44egz82e2DATCVM1ICPmRDjXYTLldQiWA2ZXIWnK0iitl5ue24 7EsWJefrIhE=", +) + +good_ds = dns.rdata.from_text( + dns.rdataclass.IN, + dns.rdatatype.DS, + "57349 5 2 53A79A3E7488AB44FFC56B2D1109F0699D1796DD977E72108B841F96 E47D7013", +) when2 = 1290425644 -abs_example = dns.name.from_text('example') +abs_example = dns.name.from_text("example") abs_dsa_keys = { abs_example: dns.rrset.from_text( - 'example.', 86400, 'IN', 'DNSKEY', - '257 3 3 CI3nCqyJsiCJHTjrNsJOT4RaszetzcJPYuoH3F9ZTVt3KJXncCVR3bwn 1w0iavKljb9hDlAYSfHbFCp4ic/rvg4p1L8vh5s8ToMjqDNl40A0hUGQ Ybx5hsECyK+qHoajilUX1phYSAD8d9WAGO3fDWzUPBuzR7o85NiZCDxz yXuNVfni0uhj9n1KYhEO5yAbbruDGN89wIZcxMKuQsdUY2GYD93ssnBv a55W6XRABYWayKZ90WkRVODLVYLSn53Pj/wwxGH+XdhIAZJXimrZL4yl My7rtBsLMqq8Ihs4Tows7LqYwY7cp6y/50tw6pj8tFqMYcPUjKZV36l1 M/2t5BVg3i7IK61Aidt6aoC3TDJtzAxg3ZxfjZWJfhHjMJqzQIfbW5b9 q1mjFsW5EUv39RaNnX+3JWPRLyDqD4pIwDyqfutMsdk/Py3paHn82FGp CaOg+nicqZ9TiMZURN/XXy5JoXUNQ3RNvbHCUiPUe18KUkY6mTfnyHld 1l9YCWmzXQVClkx/hOYxjJ4j8Ife58+Obu5X', - '256 3 3 CJE1yb9YRQiw5d2xZrMUMR+cGCTt1bp1KDCefmYKmS+Z1+q9f42ETVhx JRiQwXclYwmxborzIkSZegTNYIV6mrYwbNB27Q44c3UGcspb3PiOw5TC jNPRYEcdwGvDZ2wWy+vkSV/S9tHXY8O6ODiE6abZJDDg/RnITyi+eoDL R3KZ5n/V1f1T1b90rrV6EewhBGQJpQGDogaXb2oHww9Tm6NfXyo7SoMM pbwbzOckXv+GxRPJIQNSF4D4A9E8XCksuzVVdE/0lr37+uoiAiPia38U 5W2QWe/FJAEPLjIp2eTzf0TrADc1pKP1wrA2ASpdzpm/aX3IB5RPp8Ew S9U72eBFZJAUwg635HxJVxH1maG6atzorR566E+e0OZSaxXS9o1o6QqN 3oPlYLGPORDiExilKfez3C/x/yioOupW9K5eKF0gmtaqrHX0oq9s67f/ RIM2xVaKHgG9Vf2cgJIZkhv7sntujr+E4htnRmy9P9BxyFxsItYxPI6Z bzygHAZpGhlI/7ltEGlIwKxyTK3ZKBm67q7B' + "example.", + 86400, + "IN", + "DNSKEY", + "257 3 3 CI3nCqyJsiCJHTjrNsJOT4RaszetzcJPYuoH3F9ZTVt3KJXncCVR3bwn 1w0iavKljb9hDlAYSfHbFCp4ic/rvg4p1L8vh5s8ToMjqDNl40A0hUGQ Ybx5hsECyK+qHoajilUX1phYSAD8d9WAGO3fDWzUPBuzR7o85NiZCDxz yXuNVfni0uhj9n1KYhEO5yAbbruDGN89wIZcxMKuQsdUY2GYD93ssnBv a55W6XRABYWayKZ90WkRVODLVYLSn53Pj/wwxGH+XdhIAZJXimrZL4yl My7rtBsLMqq8Ihs4Tows7LqYwY7cp6y/50tw6pj8tFqMYcPUjKZV36l1 M/2t5BVg3i7IK61Aidt6aoC3TDJtzAxg3ZxfjZWJfhHjMJqzQIfbW5b9 q1mjFsW5EUv39RaNnX+3JWPRLyDqD4pIwDyqfutMsdk/Py3paHn82FGp CaOg+nicqZ9TiMZURN/XXy5JoXUNQ3RNvbHCUiPUe18KUkY6mTfnyHld 1l9YCWmzXQVClkx/hOYxjJ4j8Ife58+Obu5X", + "256 3 3 CJE1yb9YRQiw5d2xZrMUMR+cGCTt1bp1KDCefmYKmS+Z1+q9f42ETVhx JRiQwXclYwmxborzIkSZegTNYIV6mrYwbNB27Q44c3UGcspb3PiOw5TC jNPRYEcdwGvDZ2wWy+vkSV/S9tHXY8O6ODiE6abZJDDg/RnITyi+eoDL R3KZ5n/V1f1T1b90rrV6EewhBGQJpQGDogaXb2oHww9Tm6NfXyo7SoMM pbwbzOckXv+GxRPJIQNSF4D4A9E8XCksuzVVdE/0lr37+uoiAiPia38U 5W2QWe/FJAEPLjIp2eTzf0TrADc1pKP1wrA2ASpdzpm/aX3IB5RPp8Ew S9U72eBFZJAUwg635HxJVxH1maG6atzorR566E+e0OZSaxXS9o1o6QqN 3oPlYLGPORDiExilKfez3C/x/yioOupW9K5eKF0gmtaqrHX0oq9s67f/ RIM2xVaKHgG9Vf2cgJIZkhv7sntujr+E4htnRmy9P9BxyFxsItYxPI6Z bzygHAZpGhlI/7ltEGlIwKxyTK3ZKBm67q7B", ) } -abs_dsa_soa = dns.rrset.from_text('example.', 86400, 'IN', 'SOA', - 'ns1.example. hostmaster.example. 2 10800 3600 604800 86400') - -abs_other_dsa_soa = dns.rrset.from_text('example.', 86400, 'IN', 'SOA', - 'ns1.example. hostmaster.example. 2 10800 3600 604800 86401') - -abs_dsa_soa_rrsig = dns.rrset.from_text('example.', 86400, 'IN', 'RRSIG', - 'SOA 3 1 86400 20101129143231 20101122112731 42088 example. CGul9SuBofsktunV8cJs4eRs6u+3NCS3yaPKvBbD+pB2C76OUXDZq9U=') - -example_sep_key = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.DNSKEY, - '257 3 3 CI3nCqyJsiCJHTjrNsJOT4RaszetzcJPYuoH3F9ZTVt3KJXncCVR3bwn 1w0iavKljb9hDlAYSfHbFCp4ic/rvg4p1L8vh5s8ToMjqDNl40A0hUGQ Ybx5hsECyK+qHoajilUX1phYSAD8d9WAGO3fDWzUPBuzR7o85NiZCDxz yXuNVfni0uhj9n1KYhEO5yAbbruDGN89wIZcxMKuQsdUY2GYD93ssnBv a55W6XRABYWayKZ90WkRVODLVYLSn53Pj/wwxGH+XdhIAZJXimrZL4yl My7rtBsLMqq8Ihs4Tows7LqYwY7cp6y/50tw6pj8tFqMYcPUjKZV36l1 M/2t5BVg3i7IK61Aidt6aoC3TDJtzAxg3ZxfjZWJfhHjMJqzQIfbW5b9 q1mjFsW5EUv39RaNnX+3JWPRLyDqD4pIwDyqfutMsdk/Py3paHn82FGp CaOg+nicqZ9TiMZURN/XXy5JoXUNQ3RNvbHCUiPUe18KUkY6mTfnyHld 1l9YCWmzXQVClkx/hOYxjJ4j8Ife58+Obu5X') - -example_ds_sha1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.DS, - '18673 3 1 71b71d4f3e11bbd71b4eff12cde69f7f9215bbe7') - -example_ds_sha256 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.DS, - '18673 3 2 eb8344cbbf07c9d3d3d6c81d10c76653e28d8611a65e639ef8f716e4e4e5d913') - -example_ds_sha384 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.DS, - '18673 3 4 61ab241025c5f88d2537be04dcfba96f952adaefe0b382ecbc4108c97b75768c9e99fd16caed2a09634c51e8089fb84f') +abs_dsa_soa = dns.rrset.from_text( + "example.", + 86400, + "IN", + "SOA", + "ns1.example. hostmaster.example. 2 10800 3600 604800 86400", +) + +abs_other_dsa_soa = dns.rrset.from_text( + "example.", + 86400, + "IN", + "SOA", + "ns1.example. hostmaster.example. 2 10800 3600 604800 86401", +) + +abs_dsa_soa_rrsig = dns.rrset.from_text( + "example.", + 86400, + "IN", + "RRSIG", + "SOA 3 1 86400 20101129143231 20101122112731 42088 example. CGul9SuBofsktunV8cJs4eRs6u+3NCS3yaPKvBbD+pB2C76OUXDZq9U=", +) + +example_sep_key = dns.rdata.from_text( + dns.rdataclass.IN, + dns.rdatatype.DNSKEY, + "257 3 3 CI3nCqyJsiCJHTjrNsJOT4RaszetzcJPYuoH3F9ZTVt3KJXncCVR3bwn 1w0iavKljb9hDlAYSfHbFCp4ic/rvg4p1L8vh5s8ToMjqDNl40A0hUGQ Ybx5hsECyK+qHoajilUX1phYSAD8d9WAGO3fDWzUPBuzR7o85NiZCDxz yXuNVfni0uhj9n1KYhEO5yAbbruDGN89wIZcxMKuQsdUY2GYD93ssnBv a55W6XRABYWayKZ90WkRVODLVYLSn53Pj/wwxGH+XdhIAZJXimrZL4yl My7rtBsLMqq8Ihs4Tows7LqYwY7cp6y/50tw6pj8tFqMYcPUjKZV36l1 M/2t5BVg3i7IK61Aidt6aoC3TDJtzAxg3ZxfjZWJfhHjMJqzQIfbW5b9 q1mjFsW5EUv39RaNnX+3JWPRLyDqD4pIwDyqfutMsdk/Py3paHn82FGp CaOg+nicqZ9TiMZURN/XXy5JoXUNQ3RNvbHCUiPUe18KUkY6mTfnyHld 1l9YCWmzXQVClkx/hOYxjJ4j8Ife58+Obu5X", +) + +example_ds_sha1 = dns.rdata.from_text( + dns.rdataclass.IN, + dns.rdatatype.DS, + "18673 3 1 71b71d4f3e11bbd71b4eff12cde69f7f9215bbe7", +) + +example_ds_sha256 = dns.rdata.from_text( + dns.rdataclass.IN, + dns.rdatatype.DS, + "18673 3 2 eb8344cbbf07c9d3d3d6c81d10c76653e28d8611a65e639ef8f716e4e4e5d913", +) + +example_ds_sha384 = dns.rdata.from_text( + dns.rdataclass.IN, + dns.rdatatype.DS, + "18673 3 4 61ab241025c5f88d2537be04dcfba96f952adaefe0b382ecbc4108c97b75768c9e99fd16caed2a09634c51e8089fb84f", +) when3 = 1379801800 abs_ecdsa256_keys = { abs_example: dns.rrset.from_text( - 'example.', 86400, 'IN', 'DNSKEY', + "example.", + 86400, + "IN", + "DNSKEY", "256 3 13 +3ss1sCpdARVA61DJigEsL/8quo2a8MszKtn2gkkfxgzFs8S2UHtpb4N fY+XFmNW+JK6MsCkI3jHYN8eEQUgMw==", - "257 3 13 eJCEVH7AS3wnoaQpaNlAXH0W8wxymtT9P6P3qjN2ZCV641ED8pF7wZ5V yWfOpgTs6oaZevbJgehl/GaRPUgVyQ==" + "257 3 13 eJCEVH7AS3wnoaQpaNlAXH0W8wxymtT9P6P3qjN2ZCV641ED8pF7wZ5V yWfOpgTs6oaZevbJgehl/GaRPUgVyQ==", ) } -abs_ecdsa256_soa = dns.rrset.from_text('example.', 86400, 'IN', 'SOA', - 'ns1.example. hostmaster.example. 4 10800 3600 604800 86400') - -abs_other_ecdsa256_soa = dns.rrset.from_text('example.', 86400, 'IN', 'SOA', - 'ns1.example. hostmaster.example. 2 10800 3600 604800 86401') - -abs_ecdsa256_soa_rrsig = dns.rrset.from_text('example.', 86400, 'IN', 'RRSIG', - "SOA 13 1 86400 20130921221753 20130921221638 7460 example. Sm09SOGz1ULB5D/duwdE2Zpn8bWbVBM77H6N1wPkc42LevvVO+kZEjpq 2nq4GOMJcih52667GIAbMrwmU5P2MQ==") +abs_ecdsa256_soa = dns.rrset.from_text( + "example.", + 86400, + "IN", + "SOA", + "ns1.example. hostmaster.example. 4 10800 3600 604800 86400", +) + +abs_other_ecdsa256_soa = dns.rrset.from_text( + "example.", + 86400, + "IN", + "SOA", + "ns1.example. hostmaster.example. 2 10800 3600 604800 86401", +) + +abs_ecdsa256_soa_rrsig = dns.rrset.from_text( + "example.", + 86400, + "IN", + "RRSIG", + "SOA 13 1 86400 20130921221753 20130921221638 7460 example. Sm09SOGz1ULB5D/duwdE2Zpn8bWbVBM77H6N1wPkc42LevvVO+kZEjpq 2nq4GOMJcih52667GIAbMrwmU5P2MQ==", +) when4 = 1379804850 abs_ecdsa384_keys = { abs_example: dns.rrset.from_text( - 'example.', 86400, 'IN', 'DNSKEY', + "example.", + 86400, + "IN", + "DNSKEY", "256 3 14 1bG8qWviKNXQX3BIuG6/T5jrP1FISiLW/8qGF6BsM9DQtWYhhZUA3Owr OAEiyHAhQwjkN2kTvWiAYoPN80Ii+5ff9/atzY4F9W50P4l75Dj9PYrL HN/hLUgWMNVc9pvA", - "257 3 14 mSub2n0KRt6u2FaD5XJ3oQu0R4XvB/9vUJcyW6+oo0y+KzfQeTdkf1ro ZMVKoyWXW9zUKBYGJpMUIdbAxzrYi7f5HyZ3yDpBFz1hw9+o3CX+gtgb +RyhHfJDwwFXBid9" + "257 3 14 mSub2n0KRt6u2FaD5XJ3oQu0R4XvB/9vUJcyW6+oo0y+KzfQeTdkf1ro ZMVKoyWXW9zUKBYGJpMUIdbAxzrYi7f5HyZ3yDpBFz1hw9+o3CX+gtgb +RyhHfJDwwFXBid9", ) } -abs_ecdsa384_soa = dns.rrset.from_text('example.', 86400, 'IN', 'SOA', - 'ns1.example. hostmaster.example. 2 10800 3600 604800 86400') - -abs_other_ecdsa384_soa = dns.rrset.from_text('example.', 86400, 'IN', 'SOA', - 'ns1.example. hostmaster.example. 2 10800 3600 604800 86401') - -abs_ecdsa384_soa_rrsig = dns.rrset.from_text('example.', 86400, 'IN', 'RRSIG', - "SOA 14 1 86400 20130929021229 20130921230729 63571 example. CrnCu34EeeRz0fEhL9PLlwjpBKGYW8QjBjFQTwd+ViVLRAS8tNkcDwQE NhSV89NEjj7ze1a/JcCfcJ+/mZgnvH4NHLNg3Tf6KuLZsgs2I4kKQXEk 37oIHravPEOlGYNI") - -abs_example_com = dns.name.from_text('example.com') - -abs_ed25519_mx = dns.rrset.from_text('example.com.', 3600, 'IN', 'MX', - '10 mail.example.com.') -abs_other_ed25519_mx = dns.rrset.from_text('example.com.', 3600, 'IN', 'MX', - '11 mail.example.com.') +abs_ecdsa384_soa = dns.rrset.from_text( + "example.", + 86400, + "IN", + "SOA", + "ns1.example. hostmaster.example. 2 10800 3600 604800 86400", +) + +abs_other_ecdsa384_soa = dns.rrset.from_text( + "example.", + 86400, + "IN", + "SOA", + "ns1.example. hostmaster.example. 2 10800 3600 604800 86401", +) + +abs_ecdsa384_soa_rrsig = dns.rrset.from_text( + "example.", + 86400, + "IN", + "RRSIG", + "SOA 14 1 86400 20130929021229 20130921230729 63571 example. CrnCu34EeeRz0fEhL9PLlwjpBKGYW8QjBjFQTwd+ViVLRAS8tNkcDwQE NhSV89NEjj7ze1a/JcCfcJ+/mZgnvH4NHLNg3Tf6KuLZsgs2I4kKQXEk 37oIHravPEOlGYNI", +) + +abs_example_com = dns.name.from_text("example.com") + +abs_ed25519_mx = dns.rrset.from_text( + "example.com.", 3600, "IN", "MX", "10 mail.example.com." +) +abs_other_ed25519_mx = dns.rrset.from_text( + "example.com.", 3600, "IN", "MX", "11 mail.example.com." +) abs_ed25519_keys_1 = { abs_example_com: dns.rrset.from_text( - 'example.com', 3600, 'IN', 'DNSKEY', - '257 3 15 l02Woi0iS8Aa25FQkUd9RMzZHJpBoRQwAQEX1SxZJA4=') + "example.com", + 3600, + "IN", + "DNSKEY", + "257 3 15 l02Woi0iS8Aa25FQkUd9RMzZHJpBoRQwAQEX1SxZJA4=", + ) } -abs_ed25519_mx_rrsig_1 = dns.rrset.from_text('example.com.', 3600, 'IN', 'RRSIG', - 'MX 15 2 3600 1440021600 1438207200 3613 example.com. oL9krJun7xfBOIWcGHi7mag5/hdZrKWw15jPGrHpjQeRAvTdszaPD+QLs3fx8A4M3e23mRZ9VrbpMngwcrqNAg==') +abs_ed25519_mx_rrsig_1 = dns.rrset.from_text( + "example.com.", + 3600, + "IN", + "RRSIG", + "MX 15 2 3600 1440021600 1438207200 3613 example.com. oL9krJun7xfBOIWcGHi7mag5/hdZrKWw15jPGrHpjQeRAvTdszaPD+QLs3fx8A4M3e23mRZ9VrbpMngwcrqNAg==", +) abs_ed25519_keys_2 = { abs_example_com: dns.rrset.from_text( - 'example.com', 3600, 'IN', 'DNSKEY', - '257 3 15 zPnZ/QwEe7S8C5SPz2OfS5RR40ATk2/rYnE9xHIEijs=') + "example.com", + 3600, + "IN", + "DNSKEY", + "257 3 15 zPnZ/QwEe7S8C5SPz2OfS5RR40ATk2/rYnE9xHIEijs=", + ) } -abs_ed25519_mx_rrsig_2 = dns.rrset.from_text('example.com.', 3600, 'IN', 'RRSIG', - 'MX 15 2 3600 1440021600 1438207200 35217 example.com. zXQ0bkYgQTEFyfLyi9QoiY6D8ZdYo4wyUhVioYZXFdT410QPRITQSqJSnzQoSm5poJ7gD7AQR0O7KuI5k2pcBg==') +abs_ed25519_mx_rrsig_2 = dns.rrset.from_text( + "example.com.", + 3600, + "IN", + "RRSIG", + "MX 15 2 3600 1440021600 1438207200 35217 example.com. zXQ0bkYgQTEFyfLyi9QoiY6D8ZdYo4wyUhVioYZXFdT410QPRITQSqJSnzQoSm5poJ7gD7AQR0O7KuI5k2pcBg==", +) abs_ed448_mx = abs_ed25519_mx abs_other_ed448_mx = abs_other_ed25519_mx abs_ed448_keys_1 = { abs_example_com: dns.rrset.from_text( - 'example.com', 3600, 'IN', 'DNSKEY', - '257 3 16 3kgROaDjrh0H2iuixWBrc8g2EpBBLCdGzHmn+G2MpTPhpj/OiBVHHSfPodx1FYYUcJKm1MDpJtIA') + "example.com", + 3600, + "IN", + "DNSKEY", + "257 3 16 3kgROaDjrh0H2iuixWBrc8g2EpBBLCdGzHmn+G2MpTPhpj/OiBVHHSfPodx1FYYUcJKm1MDpJtIA", + ) } -abs_ed448_mx_rrsig_1 = dns.rrset.from_text('example.com.', 3600, 'IN', 'RRSIG', - 'MX 16 2 3600 1440021600 1438207200 9713 example.com. 3cPAHkmlnxcDHMyg7vFC34l0blBhuG1qpwLmjInI8w1CMB29FkEAIJUA0amxWndkmnBZ6SKiwZSAxGILn/NBtOXft0+Gj7FSvOKxE/07+4RQvE581N3Aj/JtIyaiYVdnYtyMWbSNyGEY2213WKsJlwEA') +abs_ed448_mx_rrsig_1 = dns.rrset.from_text( + "example.com.", + 3600, + "IN", + "RRSIG", + "MX 16 2 3600 1440021600 1438207200 9713 example.com. 3cPAHkmlnxcDHMyg7vFC34l0blBhuG1qpwLmjInI8w1CMB29FkEAIJUA0amxWndkmnBZ6SKiwZSAxGILn/NBtOXft0+Gj7FSvOKxE/07+4RQvE581N3Aj/JtIyaiYVdnYtyMWbSNyGEY2213WKsJlwEA", +) abs_ed448_keys_2 = { abs_example_com: dns.rrset.from_text( - 'example.com', 3600, 'IN', 'DNSKEY', - '257 3 16 kkreGWoccSDmUBGAe7+zsbG6ZAFQp+syPmYUurBRQc3tDjeMCJcVMRDmgcNLp5HlHAMy12VoISsA') + "example.com", + 3600, + "IN", + "DNSKEY", + "257 3 16 kkreGWoccSDmUBGAe7+zsbG6ZAFQp+syPmYUurBRQc3tDjeMCJcVMRDmgcNLp5HlHAMy12VoISsA", + ) } -abs_ed448_mx_rrsig_2 = dns.rrset.from_text('example.com.', 3600, 'IN', 'RRSIG', - 'MX 16 2 3600 1440021600 1438207200 38353 example.com. E1/oLjSGIbmLny/4fcgM1z4oL6aqo+izT3urCyHyvEp4Sp8Syg1eI+lJ57CSnZqjJP41O/9l4m0AsQ4f7qI1gVnML8vWWiyW2KXhT9kuAICUSxv5OWbf81Rq7Yu60npabODB0QFPb/rkW3kUZmQ0YQUA') +abs_ed448_mx_rrsig_2 = dns.rrset.from_text( + "example.com.", + 3600, + "IN", + "RRSIG", + "MX 16 2 3600 1440021600 1438207200 38353 example.com. E1/oLjSGIbmLny/4fcgM1z4oL6aqo+izT3urCyHyvEp4Sp8Syg1eI+lJ57CSnZqjJP41O/9l4m0AsQ4f7qI1gVnML8vWWiyW2KXhT9kuAICUSxv5OWbf81Rq7Yu60npabODB0QFPb/rkW3kUZmQ0YQUA", +) when5 = 1440021600 when5_start = 1438207200 wildcard_keys = { - abs_example_com : dns.rrset.from_text( - 'example.com', 3600, 'IN', 'DNSKEY', - '256 3 5 AwEAAecNZbwD2thg3kaRLVqCC7ASP/3F79ZIu7pCu8HvZZ6ZdinffnxT npNoVvavjouHKFYTtJyUZAfw3ZMJSsGvEerc7uh6Ex9TgvOJtWPGUtxB Nnni2u9Nk+5k6nJzMiS3sL3RLvrfZW5d2Bwbl9L5f9Ud+r2Dbm7EG3tY pMY5OE8f') + abs_example_com: dns.rrset.from_text( + "example.com", + 3600, + "IN", + "DNSKEY", + "256 3 5 AwEAAecNZbwD2thg3kaRLVqCC7ASP/3F79ZIu7pCu8HvZZ6ZdinffnxT npNoVvavjouHKFYTtJyUZAfw3ZMJSsGvEerc7uh6Ex9TgvOJtWPGUtxB Nnni2u9Nk+5k6nJzMiS3sL3RLvrfZW5d2Bwbl9L5f9Ud+r2Dbm7EG3tY pMY5OE8f", + ) } -wildcard_example_com = dns.name.from_text('*', abs_example_com) -wildcard_txt = dns.rrset.from_text('*.example.com.', 3600, 'IN', 'TXT', 'foo') -wildcard_txt_rrsig = dns.rrset.from_text('*.example.com.', 3600, 'IN', 'RRSIG', - 'TXT 5 2 3600 20200707211255 20200630180755 42486 example.com. qevJYhdAHq1VmehXQ5i+Epa32xs4zcd4qmb39pHa3GUKr1V504nxzdzQ gsT5mvDkRoY95+HAiysDON6DCDtZc69iBUIHWWuFo/OrcD2q/mWANG4x vyU28Pf0U1gN6Gd5iapKC0Ya12flKh//NQiNN2skOQ2MoF2MW2/MaAK2 HBc=') +wildcard_example_com = dns.name.from_text("*", abs_example_com) +wildcard_txt = dns.rrset.from_text("*.example.com.", 3600, "IN", "TXT", "foo") +wildcard_txt_rrsig = dns.rrset.from_text( + "*.example.com.", + 3600, + "IN", + "RRSIG", + "TXT 5 2 3600 20200707211255 20200630180755 42486 example.com. qevJYhdAHq1VmehXQ5i+Epa32xs4zcd4qmb39pHa3GUKr1V504nxzdzQ gsT5mvDkRoY95+HAiysDON6DCDtZc69iBUIHWWuFo/OrcD2q/mWANG4x vyU28Pf0U1gN6Gd5iapKC0Ya12flKh//NQiNN2skOQ2MoF2MW2/MaAK2 HBc=", +) wildcard_when = 1593541048 rsamd5_keys = { abs_example: dns.rrset.from_text( - 'example', 3600, 'in', 'dnskey', - '257 3 1 AwEAAewnoEWe+AVEnQzcZTwpl8K/QKuScYIX 9xHOhejAL1enMjE0j97Gq3XXJJPWF7eQQGHs 1De4Srv2UT0zRCLkH9r36lOR/ggANvthO/Ub Es0hlD3A58LumEPudgIDwEkxGvQAXMFTMw0x 1d/a82UtzmNoPVzFOl2r+OCXx9Jbdh/L; KSK; alg = RSAMD5; key id = 30239', - '256 3 1 AwEAAb8OJM5YcqaYG0fenUdRlrhBQ6LuwCvr 5BRlrVbVzadSDBpq+yIiklfdGNBg3WZztDy1 du62NWC/olMfc6uRe/SjqTa7IJ3MdEuZQXQw MedGdNSF73zbokx8wg7zBBr74xHczJcEpQhr ZLzwCDmIPu0yoVi3Yqdl4dm4vNBj9hAD; ZSK; alg = RSAMD5; key id = 62992') + "example", + 3600, + "in", + "dnskey", + "257 3 1 AwEAAewnoEWe+AVEnQzcZTwpl8K/QKuScYIX 9xHOhejAL1enMjE0j97Gq3XXJJPWF7eQQGHs 1De4Srv2UT0zRCLkH9r36lOR/ggANvthO/Ub Es0hlD3A58LumEPudgIDwEkxGvQAXMFTMw0x 1d/a82UtzmNoPVzFOl2r+OCXx9Jbdh/L; KSK; alg = RSAMD5; key id = 30239", + "256 3 1 AwEAAb8OJM5YcqaYG0fenUdRlrhBQ6LuwCvr 5BRlrVbVzadSDBpq+yIiklfdGNBg3WZztDy1 du62NWC/olMfc6uRe/SjqTa7IJ3MdEuZQXQw MedGdNSF73zbokx8wg7zBBr74xHczJcEpQhr ZLzwCDmIPu0yoVi3Yqdl4dm4vNBj9hAD; ZSK; alg = RSAMD5; key id = 62992", + ) } -rsamd5_ns = dns.rrset.from_text('example.', 3600, 'in', 'ns', - 'ns1.example.', 'ns2.example.') -rsamd5_ns_rrsig = dns.rrset.from_text('example.', 3600, 'in', 'rrsig', - 'NS 1 1 3600 20200825153103 20200726153103 62992 example. YPv0WVqzQBDH45mFcYGo9psCVoMoeeHeAugh 9RZuO2NmdwfQ3mmiQm7WJ3AYnzYIozFGf7CL nwn3vN8/fjsfcQgEv5xfhFTSd4IoAzJJiZAa vrI4L5590C/+aXQ8tjRmbMTPiqoudaXvsevE jP2lTFg5DCruJyFq5dnAY5b90RY=') +rsamd5_ns = dns.rrset.from_text( + "example.", 3600, "in", "ns", "ns1.example.", "ns2.example." +) +rsamd5_ns_rrsig = dns.rrset.from_text( + "example.", + 3600, + "in", + "rrsig", + "NS 1 1 3600 20200825153103 20200726153103 62992 example. YPv0WVqzQBDH45mFcYGo9psCVoMoeeHeAugh 9RZuO2NmdwfQ3mmiQm7WJ3AYnzYIozFGf7CL nwn3vN8/fjsfcQgEv5xfhFTSd4IoAzJJiZAa vrI4L5590C/+aXQ8tjRmbMTPiqoudaXvsevE jP2lTFg5DCruJyFq5dnAY5b90RY=", +) rsamd5_when = 1595781671 rsasha512_keys = { abs_example: dns.rrset.from_text( - 'example', 3600, 'in', 'dnskey', - '256 3 10 AwEAAb2JvKjZ6l5qg2ab3qqUQhLGGjsiMIuQ 2zhaXJHdTntS+8LgUXo5yLFn7YF9YL1VX9V4 5ASGxUpz0u0chjWqBNtUO3Ymzas/vck9o21M 2Ce/LrpfYsqvJaLvGf/dozW9uSeMQq1mPKYG xo4uxyhZBhZewX8znXZySrAIozBPH3yp ; ZSK; alg = RSASHA512 ; key id = 5957', - '257 3 10 AwEAAc7Lnoe+mHijJ8OOHgyJHKYantQGKx5t rIs267gOePyAL7cUt9HO1Sm3vABSGNsoHL6w 8/542SxGbT21osVISamtq7kUPTgDU9iKqCBq VdXEdzXYbhBKVoQkGPl4PflfbOgg/45xAiTi 7qOUERuRCPdKEkd4FW0tg6VfZmm7QjP1 ; KSK; alg = RSASHA512 ; key id = 53212') + "example", + 3600, + "in", + "dnskey", + "256 3 10 AwEAAb2JvKjZ6l5qg2ab3qqUQhLGGjsiMIuQ 2zhaXJHdTntS+8LgUXo5yLFn7YF9YL1VX9V4 5ASGxUpz0u0chjWqBNtUO3Ymzas/vck9o21M 2Ce/LrpfYsqvJaLvGf/dozW9uSeMQq1mPKYG xo4uxyhZBhZewX8znXZySrAIozBPH3yp ; ZSK; alg = RSASHA512 ; key id = 5957", + "257 3 10 AwEAAc7Lnoe+mHijJ8OOHgyJHKYantQGKx5t rIs267gOePyAL7cUt9HO1Sm3vABSGNsoHL6w 8/542SxGbT21osVISamtq7kUPTgDU9iKqCBq VdXEdzXYbhBKVoQkGPl4PflfbOgg/45xAiTi 7qOUERuRCPdKEkd4FW0tg6VfZmm7QjP1 ; KSK; alg = RSASHA512 ; key id = 53212", + ) } -rsasha512_ns = dns.rrset.from_text('example.', 3600, 'in', 'ns', - 'ns1.example.', 'ns2.example.') +rsasha512_ns = dns.rrset.from_text( + "example.", 3600, "in", "ns", "ns1.example.", "ns2.example." +) rsasha512_ns_rrsig = dns.rrset.from_text( - 'example.', 3600, 'in', 'rrsig', - 'NS 10 1 3600 20200825161255 20200726161255 5957 example. P9A+1zYke7yIiKEnxFMm+UIW2CIwy2WDvbx6 g8hHiI8qISe6oeKveFW23OSk9+VwFgBiOpeM ygzzFbckY7RkGbOr4TR8ogDRANt6LhV402Hu SXTV9hCLVFWU4PS+/fxxfOHCetsY5tWWSxZi zSHfgpGfsHWzQoAamag4XYDyykc=') + "example.", + 3600, + "in", + "rrsig", + "NS 10 1 3600 20200825161255 20200726161255 5957 example. P9A+1zYke7yIiKEnxFMm+UIW2CIwy2WDvbx6 g8hHiI8qISe6oeKveFW23OSk9+VwFgBiOpeM ygzzFbckY7RkGbOr4TR8ogDRANt6LhV402Hu SXTV9hCLVFWU4PS+/fxxfOHCetsY5tWWSxZi zSHfgpGfsHWzQoAamag4XYDyykc=", +) rsasha512_when = 1595783997 unknown_alg_keys = { abs_example: dns.rrset.from_text( - 'example', 3600, 'in', 'dnskey', - '256 3 100 Ym9ndXM=', - '257 3 100 Ym9ndXM=') + "example", 3600, "in", "dnskey", "256 3 100 Ym9ndXM=", "257 3 100 Ym9ndXM=" + ) } unknown_alg_ns_rrsig = dns.rrset.from_text( - 'example.', 3600, 'in', 'rrsig', - 'NS 100 1 3600 20200825161255 20200726161255 16713 example. P9A+1zYke7yIiKEnxFMm+UIW2CIwy2WDvbx6 g8hHiI8qISe6oeKveFW23OSk9+VwFgBiOpeM ygzzFbckY7RkGbOr4TR8ogDRANt6LhV402Hu SXTV9hCLVFWU4PS+/fxxfOHCetsY5tWWSxZi zSHfgpGfsHWzQoAamag4XYDyykc=') + "example.", + 3600, + "in", + "rrsig", + "NS 100 1 3600 20200825161255 20200726161255 16713 example. P9A+1zYke7yIiKEnxFMm+UIW2CIwy2WDvbx6 g8hHiI8qISe6oeKveFW23OSk9+VwFgBiOpeM ygzzFbckY7RkGbOr4TR8ogDRANt6LhV402Hu SXTV9hCLVFWU4PS+/fxxfOHCetsY5tWWSxZi zSHfgpGfsHWzQoAamag4XYDyykc=", +) fake_gost_keys = { abs_example: dns.rrset.from_text( - 'example', 3600, 'in', 'dnskey', - '256 3 12 Ym9ndXM=', - '257 3 12 Ym9ndXM=') + "example", 3600, "in", "dnskey", "256 3 12 Ym9ndXM=", "257 3 12 Ym9ndXM=" + ) } fake_gost_ns_rrsig = dns.rrset.from_text( - 'example.', 3600, 'in', 'rrsig', - 'NS 12 1 3600 20200825161255 20200726161255 16625 example. P9A+1zYke7yIiKEnxFMm+UIW2CIwy2WDvbx6 g8hHiI8qISe6oeKveFW23OSk9+VwFgBiOpeM ygzzFbckY7RkGbOr4TR8ogDRANt6LhV402Hu SXTV9hCLVFWU4PS+/fxxfOHCetsY5tWWSxZi zSHfgpGfsHWzQoAamag4XYDyykc=') + "example.", + 3600, + "in", + "rrsig", + "NS 12 1 3600 20200825161255 20200726161255 16625 example. P9A+1zYke7yIiKEnxFMm+UIW2CIwy2WDvbx6 g8hHiI8qISe6oeKveFW23OSk9+VwFgBiOpeM ygzzFbckY7RkGbOr4TR8ogDRANt6LhV402Hu SXTV9hCLVFWU4PS+/fxxfOHCetsY5tWWSxZi zSHfgpGfsHWzQoAamag4XYDyykc=", +) -@unittest.skipUnless(dns.dnssec._have_pyca, - "Python Cryptography cannot be imported") -class DNSSECValidatorTestCase(unittest.TestCase): +@unittest.skipUnless(dns.dnssec._have_pyca, "Python Cryptography cannot be imported") +class DNSSECValidatorTestCase(unittest.TestCase): def testAbsoluteRSAMD5Good(self): # type: () -> None - dns.dnssec.validate(rsamd5_ns, rsamd5_ns_rrsig, rsamd5_keys, None, - rsamd5_when) + dns.dnssec.validate(rsamd5_ns, rsamd5_ns_rrsig, rsamd5_keys, None, rsamd5_when) def testRSAMD5Keyid(self): self.assertEqual(dns.dnssec.key_id(rsamd5_keys[abs_example][0]), 30239) @@ -279,114 +452,148 @@ class DNSSECValidatorTestCase(unittest.TestCase): dns.dnssec.validate(abs_soa, abs_soa_rrsig, abs_keys, None, when) def testDuplicateKeytag(self): # type: () -> None - dns.dnssec.validate(abs_soa, abs_soa_rrsig, abs_keys_duplicate_keytag, None, when) + dns.dnssec.validate( + abs_soa, abs_soa_rrsig, abs_keys_duplicate_keytag, None, when + ) def testAbsoluteRSABad(self): # type: () -> None def bad(): # type: () -> None - dns.dnssec.validate(abs_other_soa, abs_soa_rrsig, abs_keys, None, - when) + dns.dnssec.validate(abs_other_soa, abs_soa_rrsig, abs_keys, None, when) + self.assertRaises(dns.dnssec.ValidationFailure, bad) def testRelativeRSAGood(self): # type: () -> None - dns.dnssec.validate(rel_soa, rel_soa_rrsig, rel_keys, - abs_dnspython_org, when) + dns.dnssec.validate(rel_soa, rel_soa_rrsig, rel_keys, abs_dnspython_org, when) # test the text conversion for origin too - dns.dnssec.validate(rel_soa, rel_soa_rrsig, rel_keys, - 'dnspython.org', when) + dns.dnssec.validate(rel_soa, rel_soa_rrsig, rel_keys, "dnspython.org", when) def testRelativeRSABad(self): # type: () -> None def bad(): # type: () -> None - dns.dnssec.validate(rel_other_soa, rel_soa_rrsig, rel_keys, - abs_dnspython_org, when) + dns.dnssec.validate( + rel_other_soa, rel_soa_rrsig, rel_keys, abs_dnspython_org, when + ) + self.assertRaises(dns.dnssec.ValidationFailure, bad) def testAbsoluteDSAGood(self): # type: () -> None - dns.dnssec.validate(abs_dsa_soa, abs_dsa_soa_rrsig, abs_dsa_keys, None, - when2) + dns.dnssec.validate(abs_dsa_soa, abs_dsa_soa_rrsig, abs_dsa_keys, None, when2) def testAbsoluteDSABad(self): # type: () -> None def bad(): # type: () -> None - dns.dnssec.validate(abs_other_dsa_soa, abs_dsa_soa_rrsig, - abs_dsa_keys, None, when2) + dns.dnssec.validate( + abs_other_dsa_soa, abs_dsa_soa_rrsig, abs_dsa_keys, None, when2 + ) + self.assertRaises(dns.dnssec.ValidationFailure, bad) def testAbsoluteECDSA256Good(self): # type: () -> None - dns.dnssec.validate(abs_ecdsa256_soa, abs_ecdsa256_soa_rrsig, - abs_ecdsa256_keys, None, when3) + dns.dnssec.validate( + abs_ecdsa256_soa, abs_ecdsa256_soa_rrsig, abs_ecdsa256_keys, None, when3 + ) def testAbsoluteECDSA256Bad(self): # type: () -> None def bad(): # type: () -> None - dns.dnssec.validate(abs_other_ecdsa256_soa, abs_ecdsa256_soa_rrsig, - abs_ecdsa256_keys, None, when3) + dns.dnssec.validate( + abs_other_ecdsa256_soa, + abs_ecdsa256_soa_rrsig, + abs_ecdsa256_keys, + None, + when3, + ) + self.assertRaises(dns.dnssec.ValidationFailure, bad) def testAbsoluteECDSA384Good(self): # type: () -> None - dns.dnssec.validate(abs_ecdsa384_soa, abs_ecdsa384_soa_rrsig, - abs_ecdsa384_keys, None, when4) + dns.dnssec.validate( + abs_ecdsa384_soa, abs_ecdsa384_soa_rrsig, abs_ecdsa384_keys, None, when4 + ) def testAbsoluteECDSA384Bad(self): # type: () -> None def bad(): # type: () -> None - dns.dnssec.validate(abs_other_ecdsa384_soa, abs_ecdsa384_soa_rrsig, - abs_ecdsa384_keys, None, when4) + dns.dnssec.validate( + abs_other_ecdsa384_soa, + abs_ecdsa384_soa_rrsig, + abs_ecdsa384_keys, + None, + when4, + ) + self.assertRaises(dns.dnssec.ValidationFailure, bad) def testAbsoluteED25519Good(self): # type: () -> None - dns.dnssec.validate(abs_ed25519_mx, abs_ed25519_mx_rrsig_1, - abs_ed25519_keys_1, None, when5) - dns.dnssec.validate(abs_ed25519_mx, abs_ed25519_mx_rrsig_2, - abs_ed25519_keys_2, None, when5) + dns.dnssec.validate( + abs_ed25519_mx, abs_ed25519_mx_rrsig_1, abs_ed25519_keys_1, None, when5 + ) + dns.dnssec.validate( + abs_ed25519_mx, abs_ed25519_mx_rrsig_2, abs_ed25519_keys_2, None, when5 + ) def testAbsoluteED25519Bad(self): # type: () -> None with self.assertRaises(dns.dnssec.ValidationFailure): - dns.dnssec.validate(abs_other_ed25519_mx, abs_ed25519_mx_rrsig_1, - abs_ed25519_keys_1, None, when5) + dns.dnssec.validate( + abs_other_ed25519_mx, + abs_ed25519_mx_rrsig_1, + abs_ed25519_keys_1, + None, + when5, + ) with self.assertRaises(dns.dnssec.ValidationFailure): - dns.dnssec.validate(abs_other_ed25519_mx, abs_ed25519_mx_rrsig_2, - abs_ed25519_keys_2, None, when5) + dns.dnssec.validate( + abs_other_ed25519_mx, + abs_ed25519_mx_rrsig_2, + abs_ed25519_keys_2, + None, + when5, + ) def testAbsoluteED448Good(self): # type: () -> None - dns.dnssec.validate(abs_ed448_mx, abs_ed448_mx_rrsig_1, - abs_ed448_keys_1, None, when5) - dns.dnssec.validate(abs_ed448_mx, abs_ed448_mx_rrsig_2, - abs_ed448_keys_2, None, when5) + dns.dnssec.validate( + abs_ed448_mx, abs_ed448_mx_rrsig_1, abs_ed448_keys_1, None, when5 + ) + dns.dnssec.validate( + abs_ed448_mx, abs_ed448_mx_rrsig_2, abs_ed448_keys_2, None, when5 + ) def testAbsoluteED448Bad(self): # type: () -> None with self.assertRaises(dns.dnssec.ValidationFailure): - dns.dnssec.validate(abs_other_ed448_mx, abs_ed448_mx_rrsig_1, - abs_ed448_keys_1, None, when5) + dns.dnssec.validate( + abs_other_ed448_mx, abs_ed448_mx_rrsig_1, abs_ed448_keys_1, None, when5 + ) with self.assertRaises(dns.dnssec.ValidationFailure): - dns.dnssec.validate(abs_other_ed448_mx, abs_ed448_mx_rrsig_2, - abs_ed448_keys_2, None, when5) + dns.dnssec.validate( + abs_other_ed448_mx, abs_ed448_mx_rrsig_2, abs_ed448_keys_2, None, when5 + ) def testAbsoluteRSASHA512Good(self): - dns.dnssec.validate(rsasha512_ns, rsasha512_ns_rrsig, rsasha512_keys, - None, rsasha512_when) + dns.dnssec.validate( + rsasha512_ns, rsasha512_ns_rrsig, rsasha512_keys, None, rsasha512_when + ) def testWildcardGoodAndBad(self): - dns.dnssec.validate(wildcard_txt, wildcard_txt_rrsig, - wildcard_keys, None, wildcard_when) + dns.dnssec.validate( + wildcard_txt, wildcard_txt_rrsig, wildcard_keys, None, wildcard_when + ) def clone_rrset(rrset, name): return dns.rrset.from_rdata(name, rrset.ttl, rrset[0]) - a_name = dns.name.from_text('a.example.com') + a_name = dns.name.from_text("a.example.com") a_txt = clone_rrset(wildcard_txt, a_name) a_txt_rrsig = clone_rrset(wildcard_txt_rrsig, a_name) - dns.dnssec.validate(a_txt, a_txt_rrsig, wildcard_keys, None, - wildcard_when) + dns.dnssec.validate(a_txt, a_txt_rrsig, wildcard_keys, None, wildcard_when) - abc_name = dns.name.from_text('a.b.c.example.com') + abc_name = dns.name.from_text("a.b.c.example.com") abc_txt = clone_rrset(wildcard_txt, abc_name) abc_txt_rrsig = clone_rrset(wildcard_txt_rrsig, abc_name) - dns.dnssec.validate(abc_txt, abc_txt_rrsig, wildcard_keys, None, - wildcard_when) + dns.dnssec.validate(abc_txt, abc_txt_rrsig, wildcard_keys, None, wildcard_when) - com_name = dns.name.from_text('com.') + com_name = dns.name.from_text("com.") com_txt = clone_rrset(wildcard_txt, com_name) com_txt_rrsig = clone_rrset(wildcard_txt_rrsig, abc_name) with self.assertRaises(dns.dnssec.ValidationFailure): - dns.dnssec.validate_rrsig(com_txt, com_txt_rrsig[0], wildcard_keys, - None, wildcard_when) + dns.dnssec.validate_rrsig( + com_txt, com_txt_rrsig[0], wildcard_keys, None, wildcard_when + ) def testAlternateParameterFormats(self): # type: () -> None # Pass rrset and rrsigset as (name, rdataset) tuples, not rrsets @@ -408,46 +615,63 @@ class DNSSECValidatorTestCase(unittest.TestCase): dns.dnssec.validate(abs_soa, abs_soa_rrsig, keys, None, when) # Pass origin as a string, not a name. - dns.dnssec.validate(rel_soa, rel_soa_rrsig, rel_keys, - 'dnspython.org', when) - dns.dnssec.validate_rrsig(rel_soa, rel_soa_rrsig[0], rel_keys, - 'dnspython.org', when) + dns.dnssec.validate(rel_soa, rel_soa_rrsig, rel_keys, "dnspython.org", when) + dns.dnssec.validate_rrsig( + rel_soa, rel_soa_rrsig[0], rel_keys, "dnspython.org", when + ) def testAbsoluteKeyNotFound(self): with self.assertRaises(dns.dnssec.ValidationFailure): - dns.dnssec.validate(abs_ed448_mx, abs_ed448_mx_rrsig_1, {}, None, - when5) + dns.dnssec.validate(abs_ed448_mx, abs_ed448_mx_rrsig_1, {}, None, when5) def testTimeBounds(self): # not yet valid with self.assertRaises(dns.dnssec.ValidationFailure): - dns.dnssec.validate(abs_ed448_mx, abs_ed448_mx_rrsig_1, - abs_ed448_keys_1, None, when5_start - 1) + dns.dnssec.validate( + abs_ed448_mx, + abs_ed448_mx_rrsig_1, + abs_ed448_keys_1, + None, + when5_start - 1, + ) # expired with self.assertRaises(dns.dnssec.ValidationFailure): - dns.dnssec.validate(abs_ed448_mx, abs_ed448_mx_rrsig_1, - abs_ed448_keys_1, None, when5 + 1) + dns.dnssec.validate( + abs_ed448_mx, abs_ed448_mx_rrsig_1, abs_ed448_keys_1, None, when5 + 1 + ) # expired using the current time (to test the "get the time" code # path) with self.assertRaises(dns.dnssec.ValidationFailure): - dns.dnssec.validate(abs_ed448_mx, abs_ed448_mx_rrsig_1, - abs_ed448_keys_1, None) + dns.dnssec.validate( + abs_ed448_mx, abs_ed448_mx_rrsig_1, abs_ed448_keys_1, None + ) def testOwnerNameMismatch(self): - bogus = dns.name.from_text('example.bogus') + bogus = dns.name.from_text("example.bogus") with self.assertRaises(dns.dnssec.ValidationFailure): - dns.dnssec.validate((bogus, abs_ed448_mx), abs_ed448_mx_rrsig_1, - abs_ed448_keys_1, None, when5 + 1) + dns.dnssec.validate( + (bogus, abs_ed448_mx), + abs_ed448_mx_rrsig_1, + abs_ed448_keys_1, + None, + when5 + 1, + ) def testGOSTNotSupported(self): with self.assertRaises(dns.dnssec.ValidationFailure): - dns.dnssec.validate(rsasha512_ns, fake_gost_ns_rrsig, - fake_gost_keys, None, rsasha512_when) + dns.dnssec.validate( + rsasha512_ns, fake_gost_ns_rrsig, fake_gost_keys, None, rsasha512_when + ) def testUnknownAlgorithm(self): with self.assertRaises(dns.dnssec.ValidationFailure): - dns.dnssec.validate(rsasha512_ns, unknown_alg_ns_rrsig, - unknown_alg_keys, None, rsasha512_when) + dns.dnssec.validate( + rsasha512_ns, + unknown_alg_ns_rrsig, + unknown_alg_keys, + None, + rsasha512_when, + ) class DNSSECMiscTestCase(unittest.TestCase): @@ -468,83 +692,100 @@ class DNSSECMiscTestCase(unittest.TestCase): class DNSSECMakeDSTestCase(unittest.TestCase): - def testMnemonicParser(self): - good_ds_mnemonic = dns.rdata.from_text(dns.rdataclass.IN, - dns.rdatatype.DS, - '57349 RSASHA1 2 53A79A3E7488AB44FFC56B2D1109F0699D1796DD977E72108B841F96 E47D7013') + good_ds_mnemonic = dns.rdata.from_text( + dns.rdataclass.IN, + dns.rdatatype.DS, + "57349 RSASHA1 2 53A79A3E7488AB44FFC56B2D1109F0699D1796DD977E72108B841F96 E47D7013", + ) self.assertEqual(good_ds, good_ds_mnemonic) def testMakeExampleSHA1DS(self): # type: () -> None algorithm: Any - for algorithm in ('SHA1', 'sha1', dns.dnssec.DSDigest.SHA1): + for algorithm in ("SHA1", "sha1", dns.dnssec.DSDigest.SHA1): ds = dns.dnssec.make_ds(abs_example, example_sep_key, algorithm) self.assertEqual(ds, example_ds_sha1) - ds = dns.dnssec.make_ds('example.', example_sep_key, algorithm) + ds = dns.dnssec.make_ds("example.", example_sep_key, algorithm) self.assertEqual(ds, example_ds_sha1) def testMakeExampleSHA256DS(self): # type: () -> None algorithm: Any - for algorithm in ('SHA256', 'sha256', dns.dnssec.DSDigest.SHA256): + for algorithm in ("SHA256", "sha256", dns.dnssec.DSDigest.SHA256): ds = dns.dnssec.make_ds(abs_example, example_sep_key, algorithm) self.assertEqual(ds, example_ds_sha256) def testMakeExampleSHA384DS(self): # type: () -> None algorithm: Any - for algorithm in ('SHA384', 'sha384', dns.dnssec.DSDigest.SHA384): + for algorithm in ("SHA384", "sha384", dns.dnssec.DSDigest.SHA384): ds = dns.dnssec.make_ds(abs_example, example_sep_key, algorithm) self.assertEqual(ds, example_ds_sha384) def testMakeSHA256DS(self): # type: () -> None - ds = dns.dnssec.make_ds(abs_dnspython_org, sep_key, 'SHA256') + ds = dns.dnssec.make_ds(abs_dnspython_org, sep_key, "SHA256") self.assertEqual(ds, good_ds) def testInvalidAlgorithm(self): # type: () -> None algorithm: Any - for algorithm in (10, 'shax'): + for algorithm in (10, "shax"): with self.assertRaises(dns.dnssec.UnsupportedAlgorithm): ds = dns.dnssec.make_ds(abs_example, example_sep_key, algorithm) def testReservedDigestType(self): # type: () -> None with self.assertRaises(dns.exception.SyntaxError) as cm: - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.DS, - f'18673 3 0 71b71d4f3e11bbd71b4eff12cde69f7f9215bbe7') - self.assertEqual('digest type 0 is reserved', str(cm.exception)) + dns.rdata.from_text( + dns.rdataclass.IN, + dns.rdatatype.DS, + f"18673 3 0 71b71d4f3e11bbd71b4eff12cde69f7f9215bbe7", + ) + self.assertEqual("digest type 0 is reserved", str(cm.exception)) def testUnknownDigestType(self): # type: () -> None digest_types = [dns.rdatatype.DS, dns.rdatatype.CDS] for rdtype in digest_types: - rd = dns.rdata.from_text(dns.rdataclass.IN, rdtype, - f'18673 3 5 71b71d4f3e11bbd71b4eff12cde69f7f9215bbe7') - assert isinstance(rd, dns.rdtypes.ANY.DS.DS) or isinstance(rd, dns.rdtypes.ANY.CDS.CDS) + rd = dns.rdata.from_text( + dns.rdataclass.IN, + rdtype, + f"18673 3 5 71b71d4f3e11bbd71b4eff12cde69f7f9215bbe7", + ) + assert isinstance(rd, dns.rdtypes.ANY.DS.DS) or isinstance( + rd, dns.rdtypes.ANY.CDS.CDS + ) self.assertEqual(rd.digest_type, 5) - self.assertEqual(rd.digest, bytes.fromhex('71b71d4f3e11bbd71b4eff12cde69f7f9215bbe7')) + self.assertEqual( + rd.digest, bytes.fromhex("71b71d4f3e11bbd71b4eff12cde69f7f9215bbe7") + ) def testInvalidDigestLength(self): # type: () -> None test_records = [] for rdata in [example_ds_sha1, example_ds_sha256, example_ds_sha384]: - flags, digest = rdata.to_text().rsplit(' ', 1) + flags, digest = rdata.to_text().rsplit(" ", 1) # Make sure the construction is working - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.DS, f'{flags} {digest}') + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.DS, f"{flags} {digest}" + ) - test_records.append(f'{flags} {digest[:len(digest)//2]}') # too short digest - test_records.append(f'{flags} {digest*2}') # too long digest + test_records.append( + f"{flags} {digest[:len(digest)//2]}" + ) # too short digest + test_records.append(f"{flags} {digest*2}") # too long digest for record in test_records: with self.assertRaises(dns.exception.SyntaxError) as cm: dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.DS, record) - self.assertEqual('digest length inconsistent with digest type', str(cm.exception)) + self.assertEqual( + "digest length inconsistent with digest type", str(cm.exception) + ) def testInvalidDigestLengthCDS0(self): # type: () -> None # Make sure the construction is working - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CDS, f'0 0 0 00') + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CDS, f"0 0 0 00") test_records = { - 'expecting another identifier': ['0 0 0', '0 0 0 '], - 'digest length inconsistent with digest type': ['0 0 0 0000'], - 'Odd-length string': ['0 0 0 0', '0 0 0 000'], + "expecting another identifier": ["0 0 0", "0 0 0 "], + "digest length inconsistent with digest type": ["0 0 0 0000"], + "Odd-length string": ["0 0 0 0", "0 0 0 000"], } for msg, records in test_records.items(): for record in records: @@ -553,5 +794,5 @@ class DNSSECMakeDSTestCase(unittest.TestCase): self.assertEqual(msg, str(cm.exception)) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/tests/test_doh.py b/tests/test_doh.py index bc02e95..35cb1d3 100644 --- a/tests/test_doh.py +++ b/tests/test_doh.py @@ -17,8 +17,10 @@ import unittest import random import socket + try: import ssl + _have_ssl = True except Exception: _have_ssl = False @@ -41,19 +43,19 @@ resolver_v6_addresses = [] try: with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s: s.settimeout(4) - s.connect(('8.8.8.8', 53)) + s.connect(("8.8.8.8", 53)) resolver_v4_addresses = [ - '1.1.1.1', - '8.8.8.8', + "1.1.1.1", + "8.8.8.8", # '9.9.9.9', ] except Exception: pass try: with socket.socket(socket.AF_INET6, socket.SOCK_DGRAM) as s: - s.connect(('2001:4860:4860::8888', 53)) + s.connect(("2001:4860:4860::8888", 53)) resolver_v6_addresses = [ - '2606:4700:4700::1111', + "2606:4700:4700::1111", # Google says 404 # '2001:4860:4860::8888', # '2620:fe::fe', @@ -61,22 +63,25 @@ try: except Exception: pass -KNOWN_ANYCAST_DOH_RESOLVER_URLS = ['https://cloudflare-dns.com/dns-query', - 'https://dns.google/dns-query', - # 'https://dns11.quad9.net/dns-query', - ] +KNOWN_ANYCAST_DOH_RESOLVER_URLS = [ + "https://cloudflare-dns.com/dns-query", + "https://dns.google/dns-query", + # 'https://dns11.quad9.net/dns-query', +] # Some tests require the internet to be available to run, so let's # skip those if it's not there. _network_available = True try: - socket.gethostbyname('dnspython.org') + socket.gethostbyname("dnspython.org") except socket.gaierror: _network_available = False -@unittest.skipUnless(dns.query._have_requests and _network_available, - "Python requests cannot be imported; no DNS over HTTPS (DOH)") +@unittest.skipUnless( + dns.query._have_requests and _network_available, + "Python requests cannot be imported; no DNS over HTTPS (DOH)", +) class DNSOverHTTPSTestCaseRequests(unittest.TestCase): def setUp(self): self.session = requests.sessions.Session() @@ -86,71 +91,77 @@ class DNSOverHTTPSTestCaseRequests(unittest.TestCase): def test_get_request(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, session=self.session, post=False, - timeout=4) + q = dns.message.make_query("example.com.", dns.rdatatype.A) + r = dns.query.https( + q, nameserver_url, session=self.session, post=False, timeout=4 + ) self.assertTrue(q.is_response(r)) def test_post_request(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, session=self.session, post=True, - timeout=4) + q = dns.message.make_query("example.com.", dns.rdatatype.A) + r = dns.query.https( + q, nameserver_url, session=self.session, post=True, timeout=4 + ) self.assertTrue(q.is_response(r)) def test_build_url_from_ip(self): self.assertTrue(resolver_v4_addresses or resolver_v6_addresses) if resolver_v4_addresses: nameserver_ip = random.choice(resolver_v4_addresses) - q = dns.message.make_query('example.com.', dns.rdatatype.A) + q = dns.message.make_query("example.com.", dns.rdatatype.A) # For some reason Google's DNS over HTTPS fails when you POST to # https://8.8.8.8/dns-query # So we're just going to do GET requests here - r = dns.query.https(q, nameserver_ip, session=self.session, - post=False, timeout=4) + r = dns.query.https( + q, nameserver_ip, session=self.session, post=False, timeout=4 + ) self.assertTrue(q.is_response(r)) if resolver_v6_addresses: nameserver_ip = random.choice(resolver_v6_addresses) - q = dns.message.make_query('example.com.', dns.rdatatype.A) - r = dns.query.https(q, nameserver_ip, session=self.session, - post=False, timeout=4) + q = dns.message.make_query("example.com.", dns.rdatatype.A) + r = dns.query.https( + q, nameserver_ip, session=self.session, post=False, timeout=4 + ) self.assertTrue(q.is_response(r)) def test_bootstrap_address(self): # We test this to see if v4 is available if resolver_v4_addresses: - ip = '185.228.168.168' - invalid_tls_url = 'https://{}/doh/family-filter/'.format(ip) - valid_tls_url = 'https://doh.cleanbrowsing.org/doh/family-filter/' - q = dns.message.make_query('example.com.', dns.rdatatype.A) + ip = "185.228.168.168" + invalid_tls_url = "https://{}/doh/family-filter/".format(ip) + valid_tls_url = "https://doh.cleanbrowsing.org/doh/family-filter/" + q = dns.message.make_query("example.com.", dns.rdatatype.A) # make sure CleanBrowsing's IP address will fail TLS certificate # check with self.assertRaises(SSLError): - dns.query.https(q, invalid_tls_url, session=self.session, - timeout=4) + dns.query.https(q, invalid_tls_url, session=self.session, timeout=4) # use host header - r = dns.query.https(q, valid_tls_url, session=self.session, - bootstrap_address=ip, timeout=4) + r = dns.query.https( + q, valid_tls_url, session=self.session, bootstrap_address=ip, timeout=4 + ) self.assertTrue(q.is_response(r)) def test_new_session(self): nameserver_url = random.choice(KNOWN_ANYCAST_DOH_RESOLVER_URLS) - q = dns.message.make_query('example.com.', dns.rdatatype.A) + 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)) def test_resolver(self): res = dns.resolver.Resolver(configure=False) - res.nameservers = ['https://dns.google/dns-query'] - answer = res.resolve('dns.google', 'A') + res.nameservers = ["https://dns.google/dns-query"] + answer = res.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) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) -@unittest.skipUnless(dns.query._have_httpx and _network_available and _have_ssl, - "Python httpx cannot be imported; no DNS over HTTPS (DOH)") +@unittest.skipUnless( + dns.query._have_httpx and _network_available and _have_ssl, + "Python httpx cannot be imported; no DNS over HTTPS (DOH)", +) class DNSOverHTTPSTestCaseHttpx(unittest.TestCase): def setUp(self): self.session = httpx.Client(http1=True, http2=True, verify=True) @@ -160,9 +171,10 @@ class DNSOverHTTPSTestCaseHttpx(unittest.TestCase): def test_get_request(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, session=self.session, post=False, - timeout=4) + q = dns.message.make_query("example.com.", dns.rdatatype.A) + r = dns.query.https( + q, nameserver_url, session=self.session, post=False, timeout=4 + ) self.assertTrue(q.is_response(r)) def test_get_request_http1(self): @@ -170,72 +182,80 @@ class DNSOverHTTPSTestCaseHttpx(unittest.TestCase): try: dns.query._have_http2 = False 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, session=self.session, post=False, - timeout=4) + q = dns.message.make_query("example.com.", dns.rdatatype.A) + r = dns.query.https( + q, nameserver_url, session=self.session, post=False, timeout=4 + ) self.assertTrue(q.is_response(r)) finally: dns.query._have_http2 = saved_have_http2 def test_post_request(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, session=self.session, post=True, - timeout=4) + q = dns.message.make_query("example.com.", dns.rdatatype.A) + r = dns.query.https( + q, nameserver_url, session=self.session, post=True, timeout=4 + ) self.assertTrue(q.is_response(r)) def test_build_url_from_ip(self): self.assertTrue(resolver_v4_addresses or resolver_v6_addresses) if resolver_v4_addresses: nameserver_ip = random.choice(resolver_v4_addresses) - q = dns.message.make_query('example.com.', dns.rdatatype.A) + q = dns.message.make_query("example.com.", dns.rdatatype.A) # For some reason Google's DNS over HTTPS fails when you POST to # https://8.8.8.8/dns-query # So we're just going to do GET requests here - r = dns.query.https(q, nameserver_ip, session=self.session, - post=False, timeout=4) + r = dns.query.https( + q, nameserver_ip, session=self.session, post=False, timeout=4 + ) self.assertTrue(q.is_response(r)) if resolver_v6_addresses: nameserver_ip = random.choice(resolver_v6_addresses) - q = dns.message.make_query('example.com.', dns.rdatatype.A) - r = dns.query.https(q, nameserver_ip, session=self.session, - post=False, timeout=4) + q = dns.message.make_query("example.com.", dns.rdatatype.A) + r = dns.query.https( + q, nameserver_ip, session=self.session, post=False, timeout=4 + ) self.assertTrue(q.is_response(r)) def test_bootstrap_address_fails(self): # We test this to see if v4 is available if resolver_v4_addresses: - ip = '185.228.168.168' - invalid_tls_url = 'https://{}/doh/family-filter/'.format(ip) - valid_tls_url = 'https://doh.cleanbrowsing.org/doh/family-filter/' - q = dns.message.make_query('example.com.', dns.rdatatype.A) + ip = "185.228.168.168" + invalid_tls_url = "https://{}/doh/family-filter/".format(ip) + valid_tls_url = "https://doh.cleanbrowsing.org/doh/family-filter/" + q = dns.message.make_query("example.com.", dns.rdatatype.A) # make sure CleanBrowsing's IP address will fail TLS certificate # check. with self.assertRaises(httpx.ConnectError): - dns.query.https(q, invalid_tls_url, session=self.session, - timeout=4) + dns.query.https(q, invalid_tls_url, session=self.session, timeout=4) # We can't do the Host header and SNI magic with httpx, but # we are demanding httpx be used by providing a session, so # we should get a NoDOH exception. with self.assertRaises(dns.query.NoDOH): - dns.query.https(q, valid_tls_url, session=self.session, - bootstrap_address=ip, timeout=4) + dns.query.https( + q, + valid_tls_url, + session=self.session, + bootstrap_address=ip, + timeout=4, + ) def test_new_session(self): nameserver_url = random.choice(KNOWN_ANYCAST_DOH_RESOLVER_URLS) - q = dns.message.make_query('example.com.', dns.rdatatype.A) + 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)) def test_resolver(self): res = dns.resolver.Resolver(configure=False) - res.nameservers = ['https://dns.google/dns-query'] - answer = res.resolve('dns.google', 'A') + res.nameservers = ["https://dns.google/dns-query"] + answer = res.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) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/tests/test_edns.py b/tests/test_edns.py index 427eb29..37bd970 100644 --- a/tests/test_edns.py +++ b/tests/test_edns.py @@ -25,128 +25,130 @@ from io import BytesIO import dns.edns import dns.wire + class OptionTestCase(unittest.TestCase): def testGenericOption(self): - opt = dns.edns.GenericOption(3, b'data') + opt = dns.edns.GenericOption(3, b"data") io = BytesIO() opt.to_wire(io) data = io.getvalue() - self.assertEqual(data, b'data') + self.assertEqual(data, b"data") self.assertEqual(dns.edns.option_from_wire(3, data, 0, len(data)), opt) - self.assertEqual(str(opt), 'Generic 3') + self.assertEqual(str(opt), "Generic 3") def testECSOption_prefix_length(self): - opt = dns.edns.ECSOption('1.2.255.33', 20) + opt = dns.edns.ECSOption("1.2.255.33", 20) io = BytesIO() opt.to_wire(io) data = io.getvalue() - self.assertEqual(data, b'\x00\x01\x14\x00\x01\x02\xf0') + self.assertEqual(data, b"\x00\x01\x14\x00\x01\x02\xf0") def testECSOption(self): - opt = dns.edns.ECSOption('1.2.3.4', 24) + opt = dns.edns.ECSOption("1.2.3.4", 24) io = BytesIO() opt.to_wire(io) data = io.getvalue() - self.assertEqual(data, b'\x00\x01\x18\x00\x01\x02\x03') + self.assertEqual(data, b"\x00\x01\x18\x00\x01\x02\x03") # default srclen - opt = dns.edns.ECSOption('1.2.3.4') + opt = dns.edns.ECSOption("1.2.3.4") io = BytesIO() opt.to_wire(io) data = io.getvalue() - self.assertEqual(data, b'\x00\x01\x18\x00\x01\x02\x03') - self.assertEqual(opt.to_text(), 'ECS 1.2.3.4/24 scope/0') + self.assertEqual(data, b"\x00\x01\x18\x00\x01\x02\x03") + self.assertEqual(opt.to_text(), "ECS 1.2.3.4/24 scope/0") def testECSOption25(self): - opt = dns.edns.ECSOption('1.2.3.255', 25) + opt = dns.edns.ECSOption("1.2.3.255", 25) io = BytesIO() opt.to_wire(io) data = io.getvalue() - self.assertEqual(data, b'\x00\x01\x19\x00\x01\x02\x03\x80') + self.assertEqual(data, b"\x00\x01\x19\x00\x01\x02\x03\x80") opt2 = dns.edns.option_from_wire(dns.edns.ECS, data, 0, len(data)) self.assertEqual(opt2.otype, dns.edns.ECS) - self.assertEqual(opt2.address, '1.2.3.128') + self.assertEqual(opt2.address, "1.2.3.128") self.assertEqual(opt2.srclen, 25) self.assertEqual(opt2.scopelen, 0) def testECSOption_v6(self): - opt = dns.edns.ECSOption('2001:4b98::1') + opt = dns.edns.ECSOption("2001:4b98::1") io = BytesIO() opt.to_wire(io) data = io.getvalue() - self.assertEqual(data, b'\x00\x02\x38\x00\x20\x01\x4b\x98\x00\x00\x00') + self.assertEqual(data, b"\x00\x02\x38\x00\x20\x01\x4b\x98\x00\x00\x00") opt2 = dns.edns.option_from_wire(dns.edns.ECS, data, 0, len(data)) self.assertEqual(opt2.otype, dns.edns.ECS) - self.assertEqual(opt2.address, '2001:4b98::') + self.assertEqual(opt2.address, "2001:4b98::") self.assertEqual(opt2.srclen, 56) self.assertEqual(opt2.scopelen, 0) def testECSOption_from_text_valid(self): - ecs1 = dns.edns.ECSOption.from_text('1.2.3.4/24/0') - self.assertEqual(ecs1, dns.edns.ECSOption('1.2.3.4', 24, 0)) + ecs1 = dns.edns.ECSOption.from_text("1.2.3.4/24/0") + self.assertEqual(ecs1, dns.edns.ECSOption("1.2.3.4", 24, 0)) - ecs2 = dns.edns.ECSOption.from_text('1.2.3.4/24') - self.assertEqual(ecs2, dns.edns.ECSOption('1.2.3.4', 24, 0)) + ecs2 = dns.edns.ECSOption.from_text("1.2.3.4/24") + self.assertEqual(ecs2, dns.edns.ECSOption("1.2.3.4", 24, 0)) - ecs3 = dns.edns.ECSOption.from_text('ECS 1.2.3.4/24') - self.assertEqual(ecs3, dns.edns.ECSOption('1.2.3.4', 24, 0)) + ecs3 = dns.edns.ECSOption.from_text("ECS 1.2.3.4/24") + self.assertEqual(ecs3, dns.edns.ECSOption("1.2.3.4", 24, 0)) - ecs4 = dns.edns.ECSOption.from_text('ECS 1.2.3.4/24/32') - self.assertEqual(ecs4, dns.edns.ECSOption('1.2.3.4', 24, 32)) + ecs4 = dns.edns.ECSOption.from_text("ECS 1.2.3.4/24/32") + self.assertEqual(ecs4, dns.edns.ECSOption("1.2.3.4", 24, 32)) - ecs5 = dns.edns.ECSOption.from_text('2001:4b98::1/64/56') - self.assertEqual(ecs5, dns.edns.ECSOption('2001:4b98::1', 64, 56)) + ecs5 = dns.edns.ECSOption.from_text("2001:4b98::1/64/56") + self.assertEqual(ecs5, dns.edns.ECSOption("2001:4b98::1", 64, 56)) - ecs6 = dns.edns.ECSOption.from_text('2001:4b98::1/64') - self.assertEqual(ecs6, dns.edns.ECSOption('2001:4b98::1', 64, 0)) + ecs6 = dns.edns.ECSOption.from_text("2001:4b98::1/64") + self.assertEqual(ecs6, dns.edns.ECSOption("2001:4b98::1", 64, 0)) - ecs7 = dns.edns.ECSOption.from_text('ECS 2001:4b98::1/0') - self.assertEqual(ecs7, dns.edns.ECSOption('2001:4b98::1', 0, 0)) + ecs7 = dns.edns.ECSOption.from_text("ECS 2001:4b98::1/0") + self.assertEqual(ecs7, dns.edns.ECSOption("2001:4b98::1", 0, 0)) - ecs8 = dns.edns.ECSOption.from_text('ECS 2001:4b98::1/64/128') - self.assertEqual(ecs8, dns.edns.ECSOption('2001:4b98::1', 64, 128)) + ecs8 = dns.edns.ECSOption.from_text("ECS 2001:4b98::1/64/128") + self.assertEqual(ecs8, dns.edns.ECSOption("2001:4b98::1", 64, 128)) def testECSOption_from_text_invalid(self): with self.assertRaises(ValueError): - dns.edns.ECSOption.from_text('some random text 1.2.3.4/24/0 24') + dns.edns.ECSOption.from_text("some random text 1.2.3.4/24/0 24") with self.assertRaises(ValueError): - dns.edns.ECSOption.from_text('1.2.3.4/twentyfour') + dns.edns.ECSOption.from_text("1.2.3.4/twentyfour") with self.assertRaises(ValueError): - dns.edns.ECSOption.from_text('BOGUS 1.2.3.4/5/6/7') + dns.edns.ECSOption.from_text("BOGUS 1.2.3.4/5/6/7") with self.assertRaises(ValueError): - dns.edns.ECSOption.from_text('1.2.3.4/5/6/7') + dns.edns.ECSOption.from_text("1.2.3.4/5/6/7") with self.assertRaises(ValueError): - dns.edns.ECSOption.from_text('1.2.3.4/24/O') # <-- that's not a zero + dns.edns.ECSOption.from_text("1.2.3.4/24/O") # <-- that's not a zero with self.assertRaises(ValueError): - dns.edns.ECSOption.from_text('') + dns.edns.ECSOption.from_text("") with self.assertRaises(ValueError): - dns.edns.ECSOption.from_text('1.2.3.4/2001:4b98::1/24') + dns.edns.ECSOption.from_text("1.2.3.4/2001:4b98::1/24") def testECSOption_from_wire_invalid(self): with self.assertRaises(ValueError): - opt = dns.edns.option_from_wire(dns.edns.ECS, - b'\x00\xff\x18\x00\x01\x02\x03', - 0, 7) + opt = dns.edns.option_from_wire( + dns.edns.ECS, b"\x00\xff\x18\x00\x01\x02\x03", 0, 7 + ) + def testEDEOption(self): opt = dns.edns.EDEOption(3) io = BytesIO() opt.to_wire(io) data = io.getvalue() - self.assertEqual(data, b'\x00\x03') - self.assertEqual(str(opt), 'EDE 3') + self.assertEqual(data, b"\x00\x03") + self.assertEqual(str(opt), "EDE 3") # with text - opt = dns.edns.EDEOption(16, 'test') + opt = dns.edns.EDEOption(16, "test") io = BytesIO() opt.to_wire(io) data = io.getvalue() - self.assertEqual(data, b'\x00\x10test') + self.assertEqual(data, b"\x00\x10test") def testEDEOption_invalid(self): with self.assertRaises(ValueError): @@ -157,39 +159,41 @@ class OptionTestCase(unittest.TestCase): opt = dns.edns.EDEOption(0, 0) def testEDEOption_from_wire(self): - data = b'\x00\01' + data = b"\x00\01" self.assertEqual( - dns.edns.option_from_wire(dns.edns.EDE, data, 0, 2), - dns.edns.EDEOption(1)) - data = b'\x00\01test' + dns.edns.option_from_wire(dns.edns.EDE, data, 0, 2), dns.edns.EDEOption(1) + ) + data = b"\x00\01test" self.assertEqual( dns.edns.option_from_wire(dns.edns.EDE, data, 0, 6), - dns.edns.EDEOption(1, 'test')) + dns.edns.EDEOption(1, "test"), + ) # utf-8 text MAY be null-terminated - data = b'\x00\01test\x00' + data = b"\x00\01test\x00" self.assertEqual( dns.edns.option_from_wire(dns.edns.EDE, data, 0, 7), - dns.edns.EDEOption(1, 'test')) + dns.edns.EDEOption(1, "test"), + ) def test_basic_relations(self): - o1 = dns.edns.ECSOption.from_text('1.2.3.0/24/0') - o2 = dns.edns.ECSOption.from_text('1.2.4.0/24/0') + o1 = dns.edns.ECSOption.from_text("1.2.3.0/24/0") + o2 = dns.edns.ECSOption.from_text("1.2.4.0/24/0") self.assertTrue(o1 == o1) self.assertTrue(o1 != o2) self.assertTrue(o1 < o2) self.assertTrue(o1 <= o2) self.assertTrue(o2 > o1) self.assertTrue(o2 >= o1) - o1 = dns.edns.ECSOption.from_text('1.2.4.0/23/0') - o2 = dns.edns.ECSOption.from_text('1.2.4.0/24/0') + o1 = dns.edns.ECSOption.from_text("1.2.4.0/23/0") + o2 = dns.edns.ECSOption.from_text("1.2.4.0/24/0") self.assertTrue(o1 < o2) - o1 = dns.edns.ECSOption.from_text('1.2.4.0/24/0') - o2 = dns.edns.ECSOption.from_text('1.2.4.0/24/1') + o1 = dns.edns.ECSOption.from_text("1.2.4.0/24/0") + o2 = dns.edns.ECSOption.from_text("1.2.4.0/24/1") self.assertTrue(o1 < o2) def test_incompatible_relations(self): - o1 = dns.edns.GenericOption(3, b'data') - o2 = dns.edns.ECSOption.from_text('1.2.3.5/24/0') + o1 = dns.edns.GenericOption(3, b"data") + o2 = dns.edns.ECSOption.from_text("1.2.3.5/24/0") for oper in [operator.lt, operator.le, operator.ge, operator.gt]: self.assertRaises(TypeError, lambda: oper(o1, o2)) self.assertFalse(o1 == o2) @@ -206,7 +210,7 @@ class OptionTestCase(unittest.TestCase): self.value = value def to_wire(self, file=None): - data = struct.pack('!I', self.value) + data = struct.pack("!I", self.value) if file: file.write(data) else: @@ -214,15 +218,16 @@ class OptionTestCase(unittest.TestCase): @classmethod def from_wire_parser(cls, otype, parser): - (value,) = parser.get_struct('!I') + (value,) = parser.get_struct("!I") return cls(value) try: dns.edns.register_type(U32Option, U32OptionType) - generic = dns.edns.GenericOption(U32OptionType, b'\x00\x00\x00\x01') + generic = dns.edns.GenericOption(U32OptionType, b"\x00\x00\x00\x01") wire1 = generic.to_wire() - u32 = dns.edns.option_from_wire_parser(U32OptionType, - dns.wire.Parser(wire1)) + u32 = dns.edns.option_from_wire_parser( + U32OptionType, dns.wire.Parser(wire1) + ) self.assertEqual(u32.value, 1) wire2 = u32.to_wire() self.assertEqual(wire1, wire2) diff --git a/tests/test_entropy.py b/tests/test_entropy.py index 74092e7..b502eeb 100644 --- a/tests/test_entropy.py +++ b/tests/test_entropy.py @@ -6,15 +6,16 @@ import dns.entropy # these tests are mostly for minimal coverage testing + class EntropyTestCase(unittest.TestCase): def test_pool(self): - pool = dns.entropy.EntropyPool(b'seed-value') + pool = dns.entropy.EntropyPool(b"seed-value") self.assertEqual(pool.random_8(), 94) self.assertEqual(pool.random_16(), 61532) self.assertEqual(pool.random_32(), 4226376065) self.assertEqual(pool.random_between(10, 50), 29) # stir in some not-really-entropy to exercise the stir API - pool.stir(b'not-really-entropy') + pool.stir(b"not-really-entropy") def test_pool_random(self): pool = dns.entropy.EntropyPool() @@ -24,8 +25,10 @@ class EntropyTestCase(unittest.TestCase): def test_pool_random_between(self): pool = dns.entropy.EntropyPool() + def bad(): pool.random_between(0, 4294967296) + self.assertRaises(ValueError, bad) v = pool.random_between(50, 50 + 100000) self.assertTrue(v >= 50 and v <= 50 + 100000) @@ -42,7 +45,6 @@ class EntropyTestCase(unittest.TestCase): class EntropyForcePoolTestCase(unittest.TestCase): - def setUp(self): self.saved_system_random = dns.entropy.system_random dns.entropy.system_random = None diff --git a/tests/test_exceptions.py b/tests/test_exceptions.py index caaf88a..9d98379 100644 --- a/tests/test_exceptions.py +++ b/tests/test_exceptions.py @@ -22,11 +22,10 @@ from dns.exception import DNSException class FormatedError(DNSException): fmt = "Custom format: {parameter}" - supp_kwargs = {'parameter'} + supp_kwargs = {"parameter"} class ExceptionTestCase(unittest.TestCase): - def test_custom_message(self): msg = "this is a custom message" try: @@ -42,7 +41,7 @@ class ExceptionTestCase(unittest.TestCase): def test_formatted_error(self): """Exceptions with explicit format has to respect it.""" - params = {'parameter': 'value'} + params = {"parameter": "value"} try: raise FormatedError(**params) except FormatedError as ex: @@ -59,5 +58,6 @@ class ExceptionTestCase(unittest.TestCase): with self.assertRaises(AssertionError): raise FormatedError(unsupported=2) -if __name__ == '__main__': + +if __name__ == "__main__": unittest.main() diff --git a/tests/test_flags.py b/tests/test_flags.py index 3f5fc69..27cf03b 100644 --- a/tests/test_flags.py +++ b/tests/test_flags.py @@ -21,10 +21,10 @@ import dns.flags import dns.rcode import dns.opcode -class FlagsTestCase(unittest.TestCase): +class FlagsTestCase(unittest.TestCase): def test_rcode1(self): - self.assertEqual(dns.rcode.from_text('FORMERR'), dns.rcode.FORMERR) + self.assertEqual(dns.rcode.from_text("FORMERR"), dns.rcode.FORMERR) def test_rcode2(self): self.assertEqual(dns.rcode.to_text(dns.rcode.FORMERR), "FORMERR") @@ -33,12 +33,10 @@ class FlagsTestCase(unittest.TestCase): self.assertEqual(dns.rcode.to_flags(dns.rcode.FORMERR), (1, 0)) def test_rcode4(self): - self.assertEqual(dns.rcode.to_flags(dns.rcode.BADVERS), - (0, 0x01000000)) + self.assertEqual(dns.rcode.to_flags(dns.rcode.BADVERS), (0, 0x01000000)) def test_rcode6(self): - self.assertEqual(dns.rcode.from_flags(0, 0x01000000), - dns.rcode.BADVERS) + self.assertEqual(dns.rcode.from_flags(0, 0x01000000), dns.rcode.BADVERS) def test_rcode7(self): self.assertEqual(dns.rcode.from_flags(5, 0), dns.rcode.REFUSED) @@ -46,36 +44,39 @@ class FlagsTestCase(unittest.TestCase): def test_rcode8(self): def bad(): dns.rcode.to_flags(4096) + self.assertRaises(ValueError, bad) def test_flags1(self): - self.assertEqual(dns.flags.from_text("RA RD AA QR"), - dns.flags.QR|dns.flags.AA|dns.flags.RD|dns.flags.RA) + self.assertEqual( + dns.flags.from_text("RA RD AA QR"), + dns.flags.QR | dns.flags.AA | dns.flags.RD | dns.flags.RA, + ) def test_flags2(self): - flags = dns.flags.QR|dns.flags.AA|dns.flags.RD|dns.flags.RA + flags = dns.flags.QR | dns.flags.AA | dns.flags.RD | dns.flags.RA self.assertEqual(dns.flags.to_text(flags), "QR AA RD RA") def test_rcode_badvers(self): rcode = dns.rcode.BADVERS self.assertEqual(rcode.value, 16) - self.assertEqual(rcode.name, 'BADVERS') - self.assertEqual(dns.rcode.to_text(rcode), 'BADVERS') + self.assertEqual(rcode.name, "BADVERS") + self.assertEqual(dns.rcode.to_text(rcode), "BADVERS") def test_rcode_badsig(self): rcode = dns.rcode.BADSIG self.assertEqual(rcode.value, 16) # Yes, we mean BADVERS on the next line. BADSIG and BADVERS have # the same code. - self.assertEqual(rcode.name, 'BADVERS') - self.assertEqual(dns.rcode.to_text(rcode), 'BADVERS') + self.assertEqual(rcode.name, "BADVERS") + self.assertEqual(dns.rcode.to_text(rcode), "BADVERS") # In TSIG text mode, it should be BADSIG - self.assertEqual(dns.rcode.to_text(rcode, True), 'BADSIG') + self.assertEqual(dns.rcode.to_text(rcode, True), "BADSIG") def test_unknown_rcode(self): with self.assertRaises(dns.rcode.UnknownRcode): - dns.rcode.Rcode.make('BOGUS') + dns.rcode.Rcode.make("BOGUS") -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/tests/test_generate.py b/tests/test_generate.py index 3f7c925..75f2258 100644 --- a/tests/test_generate.py +++ b/tests/test_generate.py @@ -16,7 +16,8 @@ # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. import sys -sys.path.insert(0, '../') # Force the local project to be *the* dns + +sys.path.insert(0, "../") # Force the local project to be *the* dns import unittest @@ -145,449 +146,595 @@ $GENERATE 1-10 foo$ CNAME $.0 @ 3600 IN NS ns2 """ + def _rdata_sort(a): return (a[0], a[2].rdclass, a[2].to_text()) class GenerateTestCase(unittest.TestCase): + def testFromText(self): # type: () -> None + def bad(): # type: () -> None + dns.zone.from_text(example_text, "example.", relativize=True) - def testFromText(self): # type: () -> None - def bad(): # type: () -> None - dns.zone.from_text(example_text, 'example.', relativize=True) self.assertRaises(dns.zone.NoSOA, bad) - def testFromText1(self): # type: () -> None - def bad(): # type: () -> None - dns.zone.from_text(example_text1, 'example.', relativize=True) + def testFromText1(self): # type: () -> None + def bad(): # type: () -> None + dns.zone.from_text(example_text1, "example.", relativize=True) + self.assertRaises(dns.zone.NoSOA, bad) - def testIterateAllRdatas2(self): # type: () -> None - z = dns.zone.from_text(example_text2, 'example.', relativize=True) + def testIterateAllRdatas2(self): # type: () -> None + z = dns.zone.from_text(example_text2, "example.", relativize=True) l = list(z.iterate_rdatas()) l.sort(key=_rdata_sort) - exl = [(dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns1')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns2')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, - 'foo bar 1 2 3 4 5')), - (dns.name.from_text('bar.foo', None), + exl = [ + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns1"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns2"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SOA, "foo bar 1 2 3 4 5" + ), + ), + ( + dns.name.from_text("bar.foo", None), 300, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, - '0 blaz.foo')), - (dns.name.from_text('ns1', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1')), - (dns.name.from_text('ns2', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2')), - (dns.name.from_text('foo3', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.3')), - (dns.name.from_text('foo4', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.4')), - (dns.name.from_text('foo5', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.5'))] + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, "0 blaz.foo"), + ), + ( + dns.name.from_text("ns1", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1"), + ), + ( + dns.name.from_text("ns2", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2"), + ), + ( + dns.name.from_text("foo3", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.3"), + ), + ( + dns.name.from_text("foo4", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.4"), + ), + ( + dns.name.from_text("foo5", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.5"), + ), + ] exl.sort(key=_rdata_sort) self.assertEqual(l, exl) - def testIterateAllRdatas3(self): # type: () -> None - z = dns.zone.from_text(example_text3, 'example.', relativize=True) + def testIterateAllRdatas3(self): # type: () -> None + z = dns.zone.from_text(example_text3, "example.", relativize=True) l = list(z.iterate_rdatas()) l.sort(key=_rdata_sort) - exl = [(dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns1')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns2')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, - 'foo bar 1 2 3 4 5')), - (dns.name.from_text('bar.foo', None), + exl = [ + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns1"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns2"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SOA, "foo bar 1 2 3 4 5" + ), + ), + ( + dns.name.from_text("bar.foo", None), 300, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, - '0 blaz.foo')), - (dns.name.from_text('ns1', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1')), - (dns.name.from_text('ns2', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2')), - (dns.name.from_text('foo4', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.4')), - (dns.name.from_text('foo6', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.6')), - (dns.name.from_text('foo8', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.8'))] + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, "0 blaz.foo"), + ), + ( + dns.name.from_text("ns1", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1"), + ), + ( + dns.name.from_text("ns2", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2"), + ), + ( + dns.name.from_text("foo4", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.4"), + ), + ( + dns.name.from_text("foo6", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.6"), + ), + ( + dns.name.from_text("foo8", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.8"), + ), + ] exl.sort(key=_rdata_sort) self.assertEqual(l, exl) - def testGenerate1(self): # type: () -> None - z = dns.zone.from_text(example_text4, 'example.', relativize=True) + + def testGenerate1(self): # type: () -> None + z = dns.zone.from_text(example_text4, "example.", relativize=True) l = list(z.iterate_rdatas()) l.sort(key=_rdata_sort) - exl = [(dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns1')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns2')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, - 'foo bar 1 2 3 4 5')), - (dns.name.from_text('bar.foo', None), + exl = [ + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns1"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns2"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SOA, "foo bar 1 2 3 4 5" + ), + ), + ( + dns.name.from_text("bar.foo", None), 300, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, - '0 blaz.foo')), - (dns.name.from_text('ns1', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1')), - (dns.name.from_text('ns2', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2')), - - (dns.name.from_text('wp-db01.services.mozilla.com', None), - 0, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME, - 'SERVER.FOOBAR.')), - - (dns.name.from_text('wp-db02.services.mozilla.com', None), - 0, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME, - 'SERVER.FOOBAR.')), - - (dns.name.from_text('wp-db03.services.mozilla.com', None), - 0, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME, - 'SERVER.FOOBAR.'))] + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, "0 blaz.foo"), + ), + ( + dns.name.from_text("ns1", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1"), + ), + ( + dns.name.from_text("ns2", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2"), + ), + ( + dns.name.from_text("wp-db01.services.mozilla.com", None), + 0, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.CNAME, "SERVER.FOOBAR." + ), + ), + ( + dns.name.from_text("wp-db02.services.mozilla.com", None), + 0, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.CNAME, "SERVER.FOOBAR." + ), + ), + ( + dns.name.from_text("wp-db03.services.mozilla.com", None), + 0, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.CNAME, "SERVER.FOOBAR." + ), + ), + ] exl.sort(key=_rdata_sort) self.assertEqual(l, exl) - def testGenerate2(self): # type: () -> None - z = dns.zone.from_text(example_text5, 'example.', relativize=True) + def testGenerate2(self): # type: () -> None + z = dns.zone.from_text(example_text5, "example.", relativize=True) l = list(z.iterate_rdatas()) l.sort(key=_rdata_sort) - exl = [(dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns1')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns2')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, - 'foo bar 1 2 3 4 5')), - (dns.name.from_text('bar.foo', None), + exl = [ + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns1"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns2"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SOA, "foo bar 1 2 3 4 5" + ), + ), + ( + dns.name.from_text("bar.foo", None), 300, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, - '0 blaz.foo')), - (dns.name.from_text('ns1', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1')), - (dns.name.from_text('ns2', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2')), - - (dns.name.from_text('wp-db21.services.mozilla.com', None), 0, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME, - 'SERVER.FOOBAR.')), - - (dns.name.from_text('wp-db22.services.mozilla.com', None), 0, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME, - 'SERVER.FOOBAR.')), - - (dns.name.from_text('wp-db23.services.mozilla.com', None), 0, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME, - 'SERVER.FOOBAR.'))] + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, "0 blaz.foo"), + ), + ( + dns.name.from_text("ns1", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1"), + ), + ( + dns.name.from_text("ns2", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2"), + ), + ( + dns.name.from_text("wp-db21.services.mozilla.com", None), + 0, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.CNAME, "SERVER.FOOBAR." + ), + ), + ( + dns.name.from_text("wp-db22.services.mozilla.com", None), + 0, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.CNAME, "SERVER.FOOBAR." + ), + ), + ( + dns.name.from_text("wp-db23.services.mozilla.com", None), + 0, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.CNAME, "SERVER.FOOBAR." + ), + ), + ] exl.sort(key=_rdata_sort) self.assertEqual(l, exl) - def testGenerate3(self): # type: () -> None - z = dns.zone.from_text(example_text6, 'example.', relativize=True) + def testGenerate3(self): # type: () -> None + z = dns.zone.from_text(example_text6, "example.", relativize=True) l = list(z.iterate_rdatas()) l.sort(key=_rdata_sort) - exl = [(dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns1')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns2')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, - 'foo bar 1 2 3 4 5')), - (dns.name.from_text('bar.foo', None), + exl = [ + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns1"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns2"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SOA, "foo bar 1 2 3 4 5" + ), + ), + ( + dns.name.from_text("bar.foo", None), 300, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, - '0 blaz.foo')), - (dns.name.from_text('ns1', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1')), - (dns.name.from_text('ns2', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2')), - (dns.name.from_text('wp-db21.services.mozilla.com', None), 0, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME, - 'SERVER.FOOBAR.')), - - (dns.name.from_text('wp-db22.services.mozilla.com', None), 0, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME, - 'SERVER.FOOBAR.')), - - (dns.name.from_text('wp-db23.services.mozilla.com', None), 0, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME, - 'SERVER.FOOBAR.'))] + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, "0 blaz.foo"), + ), + ( + dns.name.from_text("ns1", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1"), + ), + ( + dns.name.from_text("ns2", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2"), + ), + ( + dns.name.from_text("wp-db21.services.mozilla.com", None), + 0, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.CNAME, "SERVER.FOOBAR." + ), + ), + ( + dns.name.from_text("wp-db22.services.mozilla.com", None), + 0, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.CNAME, "SERVER.FOOBAR." + ), + ), + ( + dns.name.from_text("wp-db23.services.mozilla.com", None), + 0, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.CNAME, "SERVER.FOOBAR." + ), + ), + ] exl.sort(key=_rdata_sort) self.assertEqual(l, exl) - def testGenerate4(self): # type: () -> None - z = dns.zone.from_text(example_text7, 'example.', relativize=True) + def testGenerate4(self): # type: () -> None + z = dns.zone.from_text(example_text7, "example.", relativize=True) l = list(z.iterate_rdatas()) l.sort(key=_rdata_sort) - exl = [(dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns1')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns2')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, - 'foo bar 1 2 3 4 5')), - (dns.name.from_text('bar.foo', None), + exl = [ + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns1"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns2"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SOA, "foo bar 1 2 3 4 5" + ), + ), + ( + dns.name.from_text("bar.foo", None), 300, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, - '0 blaz.foo')), - (dns.name.from_text('ns1', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1')), - (dns.name.from_text('ns2', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2')), - - (dns.name.from_text('sync1.db', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.10.16.0')), - - (dns.name.from_text('sync2.db', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.10.16.0')), - - (dns.name.from_text('sync3.db', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.10.16.0'))] + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, "0 blaz.foo"), + ), + ( + dns.name.from_text("ns1", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1"), + ), + ( + dns.name.from_text("ns2", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2"), + ), + ( + dns.name.from_text("sync1.db", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.10.16.0"), + ), + ( + dns.name.from_text("sync2.db", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.10.16.0"), + ), + ( + dns.name.from_text("sync3.db", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.10.16.0"), + ), + ] exl.sort(key=_rdata_sort) self.assertEqual(l, exl) - def testGenerate6(self): # type: () -> None - z = dns.zone.from_text(example_text9, 'example.', relativize=True) + def testGenerate6(self): # type: () -> None + z = dns.zone.from_text(example_text9, "example.", relativize=True) l = list(z.iterate_rdatas()) l.sort(key=_rdata_sort) - exl = [(dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns1')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns2')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, - 'foo bar 1 2 3 4 5')), - (dns.name.from_text('bar.foo', None), + exl = [ + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns1"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns2"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SOA, "foo bar 1 2 3 4 5" + ), + ), + ( + dns.name.from_text("bar.foo", None), 300, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, - '0 blaz.foo')), - (dns.name.from_text('ns1', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1')), - (dns.name.from_text('ns2', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2')), - - (dns.name.from_text('wp-db01', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.10.16.0')), - (dns.name.from_text('wp-db02', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.10.16.0')), - - (dns.name.from_text('sync1.db', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.10.16.0')), - - (dns.name.from_text('sync2.db', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.10.16.0')), - - (dns.name.from_text('sync3.db', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.10.16.0'))] + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, "0 blaz.foo"), + ), + ( + dns.name.from_text("ns1", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1"), + ), + ( + dns.name.from_text("ns2", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2"), + ), + ( + dns.name.from_text("wp-db01", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.10.16.0"), + ), + ( + dns.name.from_text("wp-db02", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.10.16.0"), + ), + ( + dns.name.from_text("sync1.db", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.10.16.0"), + ), + ( + dns.name.from_text("sync2.db", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.10.16.0"), + ), + ( + dns.name.from_text("sync3.db", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.10.16.0"), + ), + ] exl.sort(key=_rdata_sort) self.assertEqual(l, exl) - def testGenerate7(self): # type: () -> None - z = dns.zone.from_text(example_text10, 'example.', relativize=True) + def testGenerate7(self): # type: () -> None + z = dns.zone.from_text(example_text10, "example.", relativize=True) l = list(z.iterate_rdatas()) l.sort(key=_rdata_sort) - exl = [(dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns1')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns2')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, - 'foo bar 1 2 3 4 5')), - (dns.name.from_text('bar.foo', None), + exl = [ + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns1"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns2"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SOA, "foo bar 1 2 3 4 5" + ), + ), + ( + dns.name.from_text("bar.foo", None), 300, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, - '0 blaz.foo')), - (dns.name.from_text('ns1', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1')), - (dns.name.from_text('ns2', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2')), - - (dns.name.from_text('27.2', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.PTR, - 'zlb1.oob')), - - (dns.name.from_text('28.2', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.PTR, - 'zlb2.oob'))] + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, "0 blaz.foo"), + ), + ( + dns.name.from_text("ns1", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1"), + ), + ( + dns.name.from_text("ns2", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2"), + ), + ( + dns.name.from_text("27.2", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.PTR, "zlb1.oob"), + ), + ( + dns.name.from_text("28.2", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.PTR, "zlb2.oob"), + ), + ] exl.sort(key=_rdata_sort) self.assertEqual(l, exl) - def testGenerate8(self): # type: () -> None - z = dns.zone.from_text(example_text11, 'example.', relativize=True) + def testGenerate8(self): # type: () -> None + z = dns.zone.from_text(example_text11, "example.", relativize=True) l = list(z.iterate_rdatas()) l.sort(key=_rdata_sort) - exl = [(dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns1')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns2')), - (dns.name.from_text('@', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, - 'foo bar 1 2 3 4 5')), - (dns.name.from_text('bar.foo', None), + exl = [ + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns1"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns2"), + ), + ( + dns.name.from_text("@", None), + 3600, + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SOA, "foo bar 1 2 3 4 5" + ), + ), + ( + dns.name.from_text("bar.foo", None), 300, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, - '0 blaz.foo')), - - (dns.name.from_text('prefix-027', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.27')), - - (dns.name.from_text('prefix-028', None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.28')), - - (dns.name.from_text('ns1', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1')), - (dns.name.from_text('ns2', None), - 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2'))] + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, "0 blaz.foo"), + ), + ( + dns.name.from_text("prefix-027", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.27"), + ), + ( + dns.name.from_text("prefix-028", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.28"), + ), + ( + dns.name.from_text("ns1", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1"), + ), + ( + dns.name.from_text("ns2", None), + 3600, + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2"), + ), + ] exl.sort(key=_rdata_sort) self.assertEqual(l, exl) def testNoOrigin(self): def bad(): - dns.zone.from_text('$GENERATE 1-10 fooo$ CNAME $.0') + dns.zone.from_text("$GENERATE 1-10 fooo$ CNAME $.0") + self.assertRaises(dns.zone.UnknownOrigin, bad) def testBadRdata(self): def bad(): - dns.zone.from_text('$GENERATE 1-10 fooo$ CNAME 10 $.0', 'example') + dns.zone.from_text("$GENERATE 1-10 fooo$ CNAME 10 $.0", "example") + self.assertRaises(dns.exception.SyntaxError, bad) def testUsesLastTTL(self): - z = dns.zone.from_text(last_ttl_input, 'example') - rrs = z.find_rrset('foo9', 'CNAME') + z = dns.zone.from_text(last_ttl_input, "example") + rrs = z.find_rrset("foo9", "CNAME") self.assertEqual(rrs.ttl, 300) def testClassMismatch(self): def bad(): - dns.zone.from_text('$GENERATE 1-10 fooo$ CH CNAME $.0', 'example') + dns.zone.from_text("$GENERATE 1-10 fooo$ CH CNAME $.0", "example") + self.assertRaises(dns.exception.SyntaxError, bad) def testUnknownRdatatype(self): def bad(): - dns.zone.from_text('$GENERATE 1-10 fooo$ BOGUSTYPE $.0', 'example') + dns.zone.from_text("$GENERATE 1-10 fooo$ BOGUSTYPE $.0", "example") + self.assertRaises(dns.exception.SyntaxError, bad) def testBadAndDangling(self): def bad1(): - dns.zone.from_text('$GENERATE bogus fooo$ CNAME $.0', - 'example.') + dns.zone.from_text("$GENERATE bogus fooo$ CNAME $.0", "example.") + self.assertRaises(dns.exception.SyntaxError, bad1) + def bad2(): - dns.zone.from_text('$GENERATE 1-10', - 'example.') + dns.zone.from_text("$GENERATE 1-10", "example.") + self.assertRaises(dns.exception.SyntaxError, bad2) + def bad3(): - dns.zone.from_text('$GENERATE 1-10 foo$', - 'example.') + dns.zone.from_text("$GENERATE 1-10 foo$", "example.") + self.assertRaises(dns.exception.SyntaxError, bad3) -if __name__ == '__main__': + +if __name__ == "__main__": unittest.main() diff --git a/tests/test_grange.py b/tests/test_grange.py index 9b5ddd2..e28b042 100644 --- a/tests/test_grange.py +++ b/tests/test_grange.py @@ -16,7 +16,8 @@ # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. import sys -sys.path.insert(0, '../') + +sys.path.insert(0, "../") import unittest @@ -26,39 +27,38 @@ import dns.grange class GRangeTestCase(unittest.TestCase): - def testFromText1(self): - start, stop, step = dns.grange.from_text('1-1') + start, stop, step = dns.grange.from_text("1-1") self.assertEqual(start, 1) self.assertEqual(stop, 1) self.assertEqual(step, 1) def testFromText2(self): - start, stop, step = dns.grange.from_text('1-4') + start, stop, step = dns.grange.from_text("1-4") self.assertEqual(start, 1) self.assertEqual(stop, 4) self.assertEqual(step, 1) def testFromText3(self): - start, stop, step = dns.grange.from_text('4-255') + start, stop, step = dns.grange.from_text("4-255") self.assertEqual(start, 4) self.assertEqual(stop, 255) self.assertEqual(step, 1) def testFromText4(self): - start, stop, step = dns.grange.from_text('1-1/1') + start, stop, step = dns.grange.from_text("1-1/1") self.assertEqual(start, 1) self.assertEqual(stop, 1) self.assertEqual(step, 1) def testFromText5(self): - start, stop, step = dns.grange.from_text('1-4/2') + start, stop, step = dns.grange.from_text("1-4/2") self.assertEqual(start, 1) self.assertEqual(stop, 4) self.assertEqual(step, 2) def testFromText6(self): - start, stop, step = dns.grange.from_text('4-255/77') + start, stop, step = dns.grange.from_text("4-255/77") self.assertEqual(start, 4) self.assertEqual(stop, 255) self.assertEqual(step, 77) @@ -68,26 +68,27 @@ class GRangeTestCase(unittest.TestCase): start = 2 stop = 1 step = 1 - dns.grange.from_text('%d-%d/%d' % (start, stop, step)) + dns.grange.from_text("%d-%d/%d" % (start, stop, step)) self.assertTrue(False) def testFailFromText2(self): with self.assertRaises(dns.exception.SyntaxError): - start = '-1' + start = "-1" stop = 3 step = 1 - dns.grange.from_text('%s-%d/%d' % (start, stop, step)) + dns.grange.from_text("%s-%d/%d" % (start, stop, step)) def testFailFromText3(self): with self.assertRaises(dns.exception.SyntaxError): start = 1 stop = 4 - step = '-2' - dns.grange.from_text('%d-%d/%s' % (start, stop, step)) + step = "-2" + dns.grange.from_text("%d-%d/%s" % (start, stop, step)) def testFailFromText4(self): with self.assertRaises(dns.exception.SyntaxError): - dns.grange.from_text('1') + dns.grange.from_text("1") + -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/tests/test_immutable.py b/tests/test_immutable.py index 8ab145e..fa762d8 100644 --- a/tests/test_immutable.py +++ b/tests/test_immutable.py @@ -7,17 +7,16 @@ import dns._immutable_ctx class ImmutableTestCase(unittest.TestCase): - def test_immutable_dict_hash(self): - d1 = dns.immutable.Dict({'a': 1, 'b': 2}) - d2 = dns.immutable.Dict({'b': 2, 'a': 1}) - d3 = {'b': 2, 'a': 1} + d1 = dns.immutable.Dict({"a": 1, "b": 2}) + d2 = dns.immutable.Dict({"b": 2, "a": 1}) + d3 = {"b": 2, "a": 1} self.assertEqual(d1, d2) self.assertEqual(d2, d3) self.assertEqual(hash(d1), hash(d2)) def test_immutable_dict_hash_cache(self): - d = dns.immutable.Dict({'a': 1, 'b': 2}) + d = dns.immutable.Dict({"a": 1, "b": 2}) self.assertEqual(d._hash, None) h1 = hash(d) self.assertEqual(d._hash, h1) @@ -26,19 +25,17 @@ class ImmutableTestCase(unittest.TestCase): def test_constify(self): items = ( - (bytearray([1, 2, 3]), b'\x01\x02\x03'), + (bytearray([1, 2, 3]), b"\x01\x02\x03"), ((1, 2, 3), (1, 2, 3)), ((1, [2], 3), (1, (2,), 3)), ([1, 2, 3], (1, 2, 3)), - ([1, {'a': [1, 2]}], - (1, dns.immutable.Dict({'a': (1, 2)}))), - ('hi', 'hi'), - (b'hi', b'hi'), + ([1, {"a": [1, 2]}], (1, dns.immutable.Dict({"a": (1, 2)}))), + ("hi", "hi"), + (b"hi", b"hi"), ) for input, expected in items: self.assertEqual(dns.immutable.constify(input), expected) - self.assertIsInstance(dns.immutable.constify({'a': 1}), - dns.immutable.Dict) + self.assertIsInstance(dns.immutable.constify({"a": 1}), dns.immutable.Dict) class DecoratorTestCase(unittest.TestCase): @@ -55,6 +52,7 @@ class DecoratorTestCase(unittest.TestCase): def __init__(self, a, b): super().__init__(a, akw=20) self.b = b + B = self.immutable_module.immutable(B) # note C is immutable by inheritance @@ -62,19 +60,23 @@ class DecoratorTestCase(unittest.TestCase): def __init__(self, a, b, c): super().__init__(a, b) self.c = c + C = self.immutable_module.immutable(C) class SA: - __slots__ = ('a', 'akw') + __slots__ = ("a", "akw") + def __init__(self, a, akw=10): self.a = a self.akw = akw class SB(A): - __slots__ = ('b') + __slots__ = "b" + def __init__(self, a, b): super().__init__(a, akw=20) self.b = b + SB = self.immutable_module.immutable(SB) # note SC is immutable by inheritance and has no slots of its own @@ -82,6 +84,7 @@ class DecoratorTestCase(unittest.TestCase): def __init__(self, a, b, c): super().__init__(a, b) self.c = c + SC = self.immutable_module.immutable(SC) return ((A, B, C), (SA, SB, SC)) @@ -115,10 +118,11 @@ class DecoratorTestCase(unittest.TestCase): self.a = a self.b = a del self.b + A = self.immutable_module.immutable(A) a = A(10) self.assertEqual(a.a, 10) - self.assertFalse(hasattr(a, 'b')) + self.assertFalse(hasattr(a, "b")) def test_no_collateral_damage(self): @@ -129,6 +133,7 @@ class DecoratorTestCase(unittest.TestCase): class A: def __init__(self, a): self.a = a + A = self.immutable_module.immutable(A) class B: @@ -136,6 +141,7 @@ class DecoratorTestCase(unittest.TestCase): self.b = a.a + b # rudely attempt to mutate innocent immutable bystander 'a' a.a = 1000 + B = self.immutable_module.immutable(B) a = A(10) diff --git a/tests/test_message.py b/tests/test_message.py index b0112ae..d2f5b0e 100644 --- a/tests/test_message.py +++ b/tests/test_message.py @@ -46,8 +46,10 @@ wwww.dnspython.org. IN A ;AUTHORITY ;ADDITIONAL""" -goodhex = b'04d201000001000000000001047777777709646e73707974686f6e' \ - b'036f726700000100010000291000000080000000' +goodhex = ( + b"04d201000001000000000001047777777709646e73707974686f6e" + b"036f726700000100010000291000000080000000" +) goodwire = binascii.unhexlify(goodhex) @@ -67,19 +69,21 @@ dnspython.org. 3600 IN NS woof.play-bow.org. woof.play-bow.org. 3600 IN A 204.152.186.150 """ -goodhex2 = '04d2 8500 0001 0001 0003 0001' \ - '09646e73707974686f6e036f726700 0006 0001' \ - 'c00c 0006 0001 00000e10 0028 ' \ - '04776f6f66c00c 0a686f73746d6173746572c00c' \ - '7764289c 00000e10 00000708 00093a80 00000e10' \ - 'c00c 0002 0001 00000e10 0014' \ - '036e7331057374616666076e6f6d696e756dc016' \ - 'c00c 0002 0001 00000e10 0006 036e7332c063' \ - 'c00c 0002 0001 00000e10 0010 04776f6f6608706c61792d626f77c016' \ - 'c091 0001 0001 00000e10 0004 cc98ba96' +goodhex2 = ( + "04d2 8500 0001 0001 0003 0001" + "09646e73707974686f6e036f726700 0006 0001" + "c00c 0006 0001 00000e10 0028 " + "04776f6f66c00c 0a686f73746d6173746572c00c" + "7764289c 00000e10 00000708 00093a80 00000e10" + "c00c 0002 0001 00000e10 0014" + "036e7331057374616666076e6f6d696e756dc016" + "c00c 0002 0001 00000e10 0006 036e7332c063" + "c00c 0002 0001 00000e10 0010 04776f6f6608706c61792d626f77c016" + "c091 0001 0001 00000e10 0004 cc98ba96" +) -goodwire2 = binascii.unhexlify(goodhex2.replace(' ', '').encode()) +goodwire2 = binascii.unhexlify(goodhex2.replace(" ", "").encode()) query_text_2 = """id 1234 opcode QUERY @@ -94,8 +98,10 @@ wwww.dnspython.org. IN A ;AUTHORITY ;ADDITIONAL""" -goodhex3 = b'04d2010f0001000000000001047777777709646e73707974686f6e' \ - b'036f726700000100010000291000ff0080000000' +goodhex3 = ( + b"04d2010f0001000000000001047777777709646e73707974686f6e" + b"036f726700000100010000291000ff0080000000" +) goodwire3 = binascii.unhexlify(goodhex3) @@ -109,8 +115,8 @@ Königsgäßchen. IN NS Königsgäßchen. 3600 IN NS Königsgäßchen. """ -class MessageTestCase(unittest.TestCase): +class MessageTestCase(unittest.TestCase): def test_class(self): m = dns.message.from_text(query_text) self.assertTrue(isinstance(m, dns.message.QueryMessage)) @@ -155,8 +161,8 @@ class MessageTestCase(unittest.TestCase): self.assertEqual(str(m), query_text_2) def test_EDNS_options_wire(self): - m = dns.message.make_query('foo', 'A') - opt = dns.edns.GenericOption(3, b'data') + m = dns.message.make_query("foo", "A") + opt = dns.edns.GenericOption(3, b"data") m.use_edns(options=[opt]) m2 = dns.message.from_wire(m.to_wire()) self.assertEqual(m2.edns, 0) @@ -167,12 +173,16 @@ class MessageTestCase(unittest.TestCase): def bad(): q = dns.message.from_text(query_text) for i in range(0, 25): - rrset = dns.rrset.from_text('foo%d.' % i, 3600, - dns.rdataclass.IN, - dns.rdatatype.A, - '10.0.0.%d' % i) + rrset = dns.rrset.from_text( + "foo%d." % i, + 3600, + dns.rdataclass.IN, + dns.rdatatype.A, + "10.0.0.%d" % i, + ) q.additional.append(rrset) q.to_wire(max_size=512) + self.assertRaises(dns.exception.TooBig, bad) def test_answer1(self): @@ -182,31 +192,34 @@ class MessageTestCase(unittest.TestCase): def test_TrailingJunk(self): def bad(): - badwire = goodwire + b'\x00' + badwire = goodwire + b"\x00" dns.message.from_wire(badwire) + self.assertRaises(dns.message.TrailingJunk, bad) def test_ShortHeader(self): def bad(): - badwire = b'\x00' * 11 + badwire = b"\x00" * 11 dns.message.from_wire(badwire) + self.assertRaises(dns.message.ShortHeader, bad) def test_RespondingToResponse(self): def bad(): - q = dns.message.make_query('foo', 'A') + q = dns.message.make_query("foo", "A") r1 = dns.message.make_response(q) dns.message.make_response(r1) + self.assertRaises(dns.exception.FormError, bad) def test_RespondingToEDNSRequestAndSettingRA(self): - q = dns.message.make_query('foo', 'A', use_edns=0) + q = dns.message.make_query("foo", "A", use_edns=0) r = dns.message.make_response(q, True) self.assertTrue(r.flags & dns.flags.RA != 0) self.assertEqual(r.edns, 0) def test_ExtendedRcodeSetting(self): - m = dns.message.make_query('foo', 'A') + m = dns.message.make_query("foo", "A") m.set_rcode(4095) self.assertEqual(m.rcode(), 4095) self.assertEqual(m.edns, 0) @@ -214,63 +227,59 @@ class MessageTestCase(unittest.TestCase): self.assertEqual(m.rcode(), 2) def test_EDNSVersionCoherence(self): - m = dns.message.make_query('foo', 'A') + m = dns.message.make_query("foo", "A") m.use_edns(1) self.assertEqual((m.ednsflags >> 16) & 0xFF, 1) def test_SettingNoEDNSOptionsImpliesNoEDNS(self): - m = dns.message.make_query('foo', 'A') + m = dns.message.make_query("foo", "A") self.assertEqual(m.edns, -1) def test_SettingEDNSFlagsImpliesEDNS(self): - m = dns.message.make_query('foo', 'A', ednsflags=dns.flags.DO) + m = dns.message.make_query("foo", "A", ednsflags=dns.flags.DO) self.assertEqual(m.edns, 0) def test_SettingEDNSPayloadImpliesEDNS(self): - m = dns.message.make_query('foo', 'A', payload=4096) + m = dns.message.make_query("foo", "A", payload=4096) self.assertEqual(m.edns, 0) def test_SettingEDNSRequestPayloadImpliesEDNS(self): - m = dns.message.make_query('foo', 'A', request_payload=4096) + m = dns.message.make_query("foo", "A", request_payload=4096) self.assertEqual(m.edns, 0) def test_SettingOptionsImpliesEDNS(self): - m = dns.message.make_query('foo', 'A', options=[]) + m = dns.message.make_query("foo", "A", options=[]) self.assertEqual(m.edns, 0) def test_FindRRset(self): a = dns.message.from_text(answer_text) - n = dns.name.from_text('dnspython.org.') + n = dns.name.from_text("dnspython.org.") rrs1 = a.find_rrset(a.answer, n, dns.rdataclass.IN, dns.rdatatype.SOA) - rrs2 = a.find_rrset(dns.message.ANSWER, n, dns.rdataclass.IN, - dns.rdatatype.SOA) + rrs2 = a.find_rrset(dns.message.ANSWER, n, dns.rdataclass.IN, dns.rdatatype.SOA) self.assertEqual(rrs1, rrs2) def test_FindRRsetUnindexed(self): a = dns.message.from_text(answer_text) a.index = None - n = dns.name.from_text('dnspython.org.') + n = dns.name.from_text("dnspython.org.") rrs1 = a.find_rrset(a.answer, n, dns.rdataclass.IN, dns.rdatatype.SOA) - rrs2 = a.find_rrset(dns.message.ANSWER, n, dns.rdataclass.IN, - dns.rdatatype.SOA) + rrs2 = a.find_rrset(dns.message.ANSWER, n, dns.rdataclass.IN, dns.rdatatype.SOA) self.assertEqual(rrs1, rrs2) def test_GetRRset(self): a = dns.message.from_text(answer_text) a.index = None - n = dns.name.from_text('dnspython.org.') + n = dns.name.from_text("dnspython.org.") rrs1 = a.get_rrset(a.answer, n, dns.rdataclass.IN, dns.rdatatype.SOA) - rrs2 = a.get_rrset(dns.message.ANSWER, n, dns.rdataclass.IN, - dns.rdatatype.SOA) + rrs2 = a.get_rrset(dns.message.ANSWER, n, dns.rdataclass.IN, dns.rdatatype.SOA) self.assertEqual(rrs1, rrs2) def test_GetNonexistentRRset(self): a = dns.message.from_text(answer_text) a.index = None - n = dns.name.from_text('dnspython.org.') + n = dns.name.from_text("dnspython.org.") rrs1 = a.get_rrset(a.answer, n, dns.rdataclass.IN, dns.rdatatype.TXT) - rrs2 = a.get_rrset(dns.message.ANSWER, n, dns.rdataclass.IN, - dns.rdatatype.TXT) + rrs2 = a.get_rrset(dns.message.ANSWER, n, dns.rdataclass.IN, dns.rdatatype.TXT) self.assertTrue(rrs1 is None) self.assertEqual(rrs1, rrs2) @@ -280,6 +289,7 @@ class MessageTestCase(unittest.TestCase): a.flags |= dns.flags.TC wire = a.to_wire(want_shuffle=False) dns.message.from_wire(wire, raise_on_truncation=True) + self.assertRaises(dns.message.Truncated, bad) def test_MessyTruncated(self): @@ -288,78 +298,82 @@ class MessageTestCase(unittest.TestCase): a.flags |= dns.flags.TC wire = a.to_wire(want_shuffle=False) dns.message.from_wire(wire[:-3], raise_on_truncation=True) + self.assertRaises(dns.message.Truncated, bad) def test_IDNA_2003(self): a = dns.message.from_text(idna_text, idna_codec=dns.name.IDNA_2003) - rrs = dns.rrset.from_text_list('xn--knigsgsschen-lcb0w.', 30, - 'in', 'ns', - ['xn--knigsgsschen-lcb0w.'], - idna_codec=dns.name.IDNA_2003) + rrs = dns.rrset.from_text_list( + "xn--knigsgsschen-lcb0w.", + 30, + "in", + "ns", + ["xn--knigsgsschen-lcb0w."], + idna_codec=dns.name.IDNA_2003, + ) self.assertEqual(a.answer[0], rrs) - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def test_IDNA_2008(self): a = dns.message.from_text(idna_text, idna_codec=dns.name.IDNA_2008) - rrs = dns.rrset.from_text_list('xn--knigsgchen-b4a3dun.', 30, - 'in', 'ns', - ['xn--knigsgchen-b4a3dun.'], - idna_codec=dns.name.IDNA_2008) + rrs = dns.rrset.from_text_list( + "xn--knigsgchen-b4a3dun.", + 30, + "in", + "ns", + ["xn--knigsgchen-b4a3dun."], + idna_codec=dns.name.IDNA_2008, + ) self.assertEqual(a.answer[0], rrs) def test_bad_section_number(self): - m = dns.message.make_query('foo', 'A') - self.assertRaises(ValueError, - lambda: m.section_number(123)) + m = dns.message.make_query("foo", "A") + self.assertRaises(ValueError, lambda: m.section_number(123)) def test_section_from_number(self): - m = dns.message.make_query('foo', 'A') - self.assertEqual(m.section_from_number(dns.message.QUESTION), - m.question) - self.assertEqual(m.section_from_number(dns.message.ANSWER), - m.answer) - self.assertEqual(m.section_from_number(dns.message.AUTHORITY), - m.authority) - self.assertEqual(m.section_from_number(dns.message.ADDITIONAL), - m.additional) - self.assertRaises(ValueError, - lambda: m.section_from_number(999)) + m = dns.message.make_query("foo", "A") + self.assertEqual(m.section_from_number(dns.message.QUESTION), m.question) + self.assertEqual(m.section_from_number(dns.message.ANSWER), m.answer) + self.assertEqual(m.section_from_number(dns.message.AUTHORITY), m.authority) + self.assertEqual(m.section_from_number(dns.message.ADDITIONAL), m.additional) + self.assertRaises(ValueError, lambda: m.section_from_number(999)) def test_wanting_EDNS_true_is_EDNS0(self): - m = dns.message.make_query('foo', 'A') + m = dns.message.make_query("foo", "A") self.assertEqual(m.edns, -1) m.use_edns(True) self.assertEqual(m.edns, 0) def test_wanting_DNSSEC_turns_on_EDNS(self): - m = dns.message.make_query('foo', 'A') + m = dns.message.make_query("foo", "A") self.assertEqual(m.edns, -1) m.want_dnssec() self.assertEqual(m.edns, 0) self.assertTrue(m.ednsflags & dns.flags.DO) def test_EDNS_default_payload_is_1232(self): - m = dns.message.make_query('foo', 'A') + m = dns.message.make_query("foo", "A") m.use_edns() self.assertEqual(m.payload, dns.message.DEFAULT_EDNS_PAYLOAD) def test_from_file(self): - m = dns.message.from_file(here('query')) + m = dns.message.from_file(here("query")) expected = dns.message.from_text(query_text) self.assertEqual(m, expected) def test_explicit_header_comment(self): - m = dns.message.from_text(';HEADER\n' + query_text) + m = dns.message.from_text(";HEADER\n" + query_text) expected = dns.message.from_text(query_text) self.assertEqual(m, expected) def test_repr(self): q = dns.message.from_text(query_text) - self.assertEqual(repr(q), '<DNS message, ID 1234>') + self.assertEqual(repr(q), "<DNS message, ID 1234>") def test_non_question_setters(self): - rrset = dns.rrset.from_text('foo', 300, 'in', 'a', '10.0.0.1') + rrset = dns.rrset.from_text("foo", 300, "in", "a", "10.0.0.1") q = dns.message.QueryMessage(id=1) q.answer = [rrset] self.assertEqual(q.sections[1], [rrset]) @@ -372,7 +386,7 @@ class MessageTestCase(unittest.TestCase): self.assertEqual(q.sections[3], [rrset]) def test_is_a_response_empty_question(self): - q = dns.message.make_query('www.dnspython.org.', 'a') + q = dns.message.make_query("www.dnspython.org.", "a") r = dns.message.make_response(q) r.question = [] r.set_rcode(dns.rcode.FORMERR) @@ -386,8 +400,8 @@ class MessageTestCase(unittest.TestCase): self.assertFalse(q.is_response(r)) r = dns.update.UpdateMessage(id=1) self.assertFalse(q.is_response(r)) - q1 = dns.message.make_query('www.dnspython.org.', 'a') - q2 = dns.message.make_query('www.google.com.', 'a') + q1 = dns.message.make_query("www.dnspython.org.", "a") + q2 = dns.message.make_query("www.google.com.", "a") # Give them the same id, as we want to test if responses for # differing questions are rejected. q1.id = 1 @@ -403,17 +417,22 @@ class MessageTestCase(unittest.TestCase): # something in the response's question section that is not in # the question's. We have to do multiple questions to test # this :) - r = dns.message.make_query('www.dnspython.org.', 'a') + r = dns.message.make_query("www.dnspython.org.", "a") r.flags |= dns.flags.QR r.id = 1 - r.find_rrset(r.question, dns.name.from_text('example'), - dns.rdataclass.IN, dns.rdatatype.A, create=True, - force_unique=True) + r.find_rrset( + r.question, + dns.name.from_text("example"), + dns.rdataclass.IN, + dns.rdatatype.A, + create=True, + force_unique=True, + ) self.assertFalse(q1.is_response(r)) def test_more_not_equal_cases(self): - q1 = dns.message.make_query('www.dnspython.org.', 'a') - q2 = dns.message.make_query('www.dnspython.org.', 'a') + q1 = dns.message.make_query("www.dnspython.org.", "a") + q2 = dns.message.make_query("www.dnspython.org.", "a") # ensure ids are same q1.id = 1 q2.id = 1 @@ -421,39 +440,49 @@ class MessageTestCase(unittest.TestCase): q2.flags |= dns.flags.QR self.assertFalse(q1 == q2) q2.flags = q1.flags - q2.find_rrset(q2.question, dns.name.from_text('example'), - dns.rdataclass.IN, dns.rdatatype.A, create=True, - force_unique=True) + q2.find_rrset( + q2.question, + dns.name.from_text("example"), + dns.rdataclass.IN, + dns.rdatatype.A, + create=True, + force_unique=True, + ) self.assertFalse(q1 == q2) def test_edns_properties(self): - q = dns.message.make_query('www.dnspython.org.', 'a') + q = dns.message.make_query("www.dnspython.org.", "a") self.assertEqual(q.edns, -1) self.assertEqual(q.payload, 0) self.assertEqual(q.options, ()) - q = dns.message.make_query('www.dnspython.org.', 'a', use_edns=0, - payload=4096) + q = dns.message.make_query("www.dnspython.org.", "a", use_edns=0, payload=4096) self.assertEqual(q.edns, 0) self.assertEqual(q.payload, 4096) self.assertEqual(q.options, ()) def test_setting_id(self): - q = dns.message.make_query('www.dnspython.org.', 'a', id=12345) + q = dns.message.make_query("www.dnspython.org.", "a", id=12345) self.assertEqual(q.id, 12345) def test_setting_flags(self): - q = dns.message.make_query('www.dnspython.org.', 'a', - flags=dns.flags.RD|dns.flags.CD) - self.assertEqual(q.flags, dns.flags.RD|dns.flags.CD) + q = dns.message.make_query( + "www.dnspython.org.", "a", flags=dns.flags.RD | dns.flags.CD + ) + self.assertEqual(q.flags, dns.flags.RD | dns.flags.CD) self.assertEqual(q.flags, 0x0110) def test_generic_message_class(self): q1 = dns.message.Message(id=1) q1.set_opcode(dns.opcode.NOTIFY) q1.flags |= dns.flags.AA - q1.find_rrset(q1.question, dns.name.from_text('example'), - dns.rdataclass.IN, dns.rdatatype.SOA, create=True, - force_unique=True) + q1.find_rrset( + q1.question, + dns.name.from_text("example"), + dns.rdataclass.IN, + dns.rdatatype.SOA, + create=True, + force_unique=True, + ) w = q1.to_wire() q2 = dns.message.from_wire(w) self.assertTrue(isinstance(q2, dns.message.Message)) @@ -478,7 +507,7 @@ class MessageTestCase(unittest.TestCase): dns.message.from_wire(wire) # Owner name not root name q = dns.message.Message(id=1) - rrs = dns.rrset.from_rdata('foo.', 0, opt) + rrs = dns.rrset.from_rdata("foo.", 0, opt) q.additional.append(rrs) wire = q.to_wire() with self.assertRaises(dns.message.BadEDNS): @@ -493,12 +522,20 @@ class MessageTestCase(unittest.TestCase): dns.message.from_wire(wire) def test_bad_tsig(self): - keyname = dns.name.from_text('key.') + keyname = dns.name.from_text("key.") # Not in additional q = dns.message.Message(id=1) - tsig = dns.rdtypes.ANY.TSIG.TSIG(dns.rdataclass.ANY, dns.rdatatype.TSIG, - dns.tsig.HMAC_SHA256, 0, 300, b'1234', - 0, 0, b'') + tsig = dns.rdtypes.ANY.TSIG.TSIG( + dns.rdataclass.ANY, + dns.rdatatype.TSIG, + dns.tsig.HMAC_SHA256, + 0, + 300, + b"1234", + 0, + 0, + b"", + ) rrs = dns.rrset.from_rdata(keyname, 0, tsig) q.answer.append(rrs) wire = q.to_wire() @@ -512,31 +549,39 @@ class MessageTestCase(unittest.TestCase): with self.assertRaises(dns.message.BadTSIG): dns.message.from_wire(wire) # Class not ANY - tsig = dns.rdtypes.ANY.TSIG.TSIG(dns.rdataclass.IN, dns.rdatatype.TSIG, - dns.tsig.HMAC_SHA256, 0, 300, b'1234', - 0, 0, b'') + tsig = dns.rdtypes.ANY.TSIG.TSIG( + dns.rdataclass.IN, + dns.rdatatype.TSIG, + dns.tsig.HMAC_SHA256, + 0, + 300, + b"1234", + 0, + 0, + b"", + ) rrs = dns.rrset.from_rdata(keyname, 0, tsig) wire = q.to_wire() with self.assertRaises(dns.message.BadTSIG): dns.message.from_wire(wire) def test_read_no_content_message(self): - m = dns.message.from_text(';comment') + m = dns.message.from_text(";comment") self.assertIsInstance(m, dns.message.QueryMessage) def test_eflags_turns_on_edns(self): - m = dns.message.from_text('eflags DO') + m = dns.message.from_text("eflags DO") self.assertIsInstance(m, dns.message.QueryMessage) self.assertEqual(m.edns, 0) def test_payload_turns_on_edns(self): - m = dns.message.from_text('payload 1200') + m = dns.message.from_text("payload 1200") self.assertIsInstance(m, dns.message.QueryMessage) self.assertEqual(m.payload, 1200) def test_bogus_header(self): with self.assertRaises(dns.message.UnknownHeaderField): - dns.message.from_text('bogus foo') + dns.message.from_text("bogus foo") def test_question_only(self): m = dns.message.from_text(answer_text) @@ -549,142 +594,178 @@ class MessageTestCase(unittest.TestCase): self.assertEqual(len(r.additional), 0) def test_bad_resolve_chaining(self): - r = dns.message.make_query('www.dnspython.org.', 'a') + r = dns.message.make_query("www.dnspython.org.", "a") with self.assertRaises(dns.message.NotQueryResponse): r.resolve_chaining() r.flags |= dns.flags.QR r.id = 1 - r.find_rrset(r.question, dns.name.from_text('example'), - dns.rdataclass.IN, dns.rdatatype.A, create=True, - force_unique=True) + r.find_rrset( + r.question, + dns.name.from_text("example"), + dns.rdataclass.IN, + dns.rdatatype.A, + create=True, + force_unique=True, + ) with self.assertRaises(dns.exception.FormError): r.resolve_chaining() def test_resolve_chaining_no_infinite_loop(self): - r = dns.message.from_text('''id 1 + r = dns.message.from_text( + """id 1 flags QR ;QUESTION www.example. IN CNAME ;AUTHORITY example. 300 IN SOA . . 1 2 3 4 5 -''') +""" + ) # passing is not going into an infinite loop in this call result = r.resolve_chaining() - self.assertEqual(result.canonical_name, - dns.name.from_text('www.example.')) + self.assertEqual(result.canonical_name, dns.name.from_text("www.example.")) self.assertEqual(result.minimum_ttl, 5) self.assertIsNone(result.answer) def test_bad_text_questions(self): with self.assertRaises(dns.exception.SyntaxError): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 ;QUESTION example. -''') +""" + ) with self.assertRaises(dns.exception.SyntaxError): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 ;QUESTION example. IN -''') +""" + ) with self.assertRaises(dns.rdatatype.UnknownRdatatype): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 ;QUESTION example. INA -''') +""" + ) with self.assertRaises(dns.rdatatype.UnknownRdatatype): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 ;QUESTION example. IN BOGUS -''') +""" + ) def test_bad_text_rrs(self): with self.assertRaises(dns.exception.SyntaxError): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 flags QR ;QUESTION example. IN A ;ANSWER example. -''') +""" + ) with self.assertRaises(dns.exception.SyntaxError): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 flags QR ;QUESTION example. IN A ;ANSWER example. IN -''') +""" + ) with self.assertRaises(dns.exception.SyntaxError): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 flags QR ;QUESTION example. IN A ;ANSWER example. 300 -''') +""" + ) with self.assertRaises(dns.rdatatype.UnknownRdatatype): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 flags QR ;QUESTION example. IN A ;ANSWER example. 30a IN A -''') +""" + ) with self.assertRaises(dns.rdatatype.UnknownRdatatype): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 flags QR ;QUESTION example. IN A ;ANSWER example. 300 INA A -''') +""" + ) with self.assertRaises(dns.exception.UnexpectedEnd): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 flags QR ;QUESTION example. IN A ;ANSWER example. 300 IN A -''') +""" + ) with self.assertRaises(dns.exception.SyntaxError): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 flags QR opcode UPDATE ;ZONE example. IN SOA ;UPDATE example. 300 IN A -''') +""" + ) with self.assertRaises(dns.exception.SyntaxError): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 flags QR opcode UPDATE ;ZONE example. IN SOA ;UPDATE example. 300 NONE A -''') +""" + ) with self.assertRaises(dns.exception.SyntaxError): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 flags QR opcode UPDATE ;ZONE example. IN SOA ;PREREQ example. 300 NONE A 10.0.0.1 -''') +""" + ) with self.assertRaises(dns.exception.SyntaxError): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 flags QR ;ANSWER 300 IN A 10.0.0.1 -''') +""" + ) with self.assertRaises(dns.exception.SyntaxError): - dns.message.from_text('''id 1 + dns.message.from_text( + """id 1 flags QR ;QUESTION IN SOA -''') +""" + ) def test_from_wire_makes_Flag(self): m = dns.message.from_wire(goodwire) @@ -693,7 +774,7 @@ flags QR def test_continue_on_error(self): good_message = dns.message.from_text( -"""id 1234 + """id 1234 opcode QUERY rcode NOERROR flags QR AA RD @@ -703,21 +784,20 @@ www.dnspython.org. IN SOA www.dnspython.org. 300 IN SOA . . 1 2 3 4 4294967295 www.dnspython.org. 300 IN A 1.2.3.4 www.dnspython.org. 300 IN AAAA ::1 -""") +""" + ) wire = good_message.to_wire() # change ANCOUNT to 255 - bad_wire = wire[:6] + b'\x00\xff' + wire[8:] + bad_wire = wire[:6] + b"\x00\xff" + wire[8:] # change AAAA into rdata with rdlen 0 - bad_wire = bad_wire[:-18] + b'\x00' * 2 + bad_wire = bad_wire[:-18] + b"\x00" * 2 m = dns.message.from_wire(bad_wire, continue_on_error=True) self.assertEqual(len(m.errors), 2) print(m.errors) - self.assertEqual(str(m.errors[0].exception), - 'IPv6 addresses are 16 bytes long') - self.assertEqual(str(m.errors[1].exception), - 'DNS message is malformed.') + self.assertEqual(str(m.errors[0].exception), "IPv6 addresses are 16 bytes long") + self.assertEqual(str(m.errors[1].exception), "DNS message is malformed.") expected_message = dns.message.from_text( -"""id 1234 + """id 1234 opcode QUERY rcode NOERROR flags QR AA RD @@ -726,9 +806,10 @@ www.dnspython.org. IN SOA ;ANSWER www.dnspython.org. 300 IN SOA . . 1 2 3 4 4294967295 www.dnspython.org. 300 IN A 1.2.3.4 -""") +""" + ) self.assertEqual(m, expected_message) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/tests/test_name.py b/tests/test_name.py index 45f8379..815fb10 100644 --- a/tests/test_name.py +++ b/tests/test_name.py @@ -16,7 +16,7 @@ # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -from typing import Dict # pylint: disable=unused-import +from typing import Dict # pylint: disable=unused-import import copy import operator import pickle @@ -33,58 +33,58 @@ import dns.e164 class NameTestCase(unittest.TestCase): def setUp(self): - self.origin = dns.name.from_text('example.') + self.origin = dns.name.from_text("example.") def testFromTextRel1(self): - n = dns.name.from_text('foo.bar') - self.assertEqual(n.labels, (b'foo', b'bar', b'')) + n = dns.name.from_text("foo.bar") + self.assertEqual(n.labels, (b"foo", b"bar", b"")) def testFromTextRel2(self): - n = dns.name.from_text('foo.bar', origin=self.origin) - self.assertEqual(n.labels, (b'foo', b'bar', b'example', b'')) + n = dns.name.from_text("foo.bar", origin=self.origin) + self.assertEqual(n.labels, (b"foo", b"bar", b"example", b"")) def testFromTextRel3(self): - n = dns.name.from_text('foo.bar', origin=None) - self.assertEqual(n.labels, (b'foo', b'bar')) + n = dns.name.from_text("foo.bar", origin=None) + self.assertEqual(n.labels, (b"foo", b"bar")) def testFromTextRel4(self): - n = dns.name.from_text('@', origin=None) + n = dns.name.from_text("@", origin=None) self.assertEqual(n, dns.name.empty) def testFromTextRel5(self): - n = dns.name.from_text('@', origin=self.origin) + n = dns.name.from_text("@", origin=self.origin) self.assertEqual(n, self.origin) def testFromTextAbs1(self): - n = dns.name.from_text('foo.bar.') - self.assertEqual(n.labels, (b'foo', b'bar', b'')) + n = dns.name.from_text("foo.bar.") + self.assertEqual(n.labels, (b"foo", b"bar", b"")) def testTortureFromText(self): good = [ - br'.', - br'a', - br'a.', - br'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', - br'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', - br'\000.\008.\010.\032.\046.\092.\099.\255', - br'\\', - br'\..\.', - br'\\.\\', - br'!"#%&/()=+-', - br'\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255.\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255.\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255.\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255', - ] + rb".", + rb"a", + rb"a.", + rb"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + rb"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + rb"\000.\008.\010.\032.\046.\092.\099.\255", + rb"\\", + rb"\..\.", + rb"\\.\\", + rb'!"#%&/()=+-', + rb"\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255.\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255.\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255.\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255", + ] bad = [ - br'..', - br'.a', - br'\\..', - b'\\', # yes, we don't want the 'r' prefix! - br'\0', - br'\00', - br'\00Z', - br'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', - br'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', - br'\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255.\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255.\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255.\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255', - ] + rb"..", + rb".a", + rb"\\..", + b"\\", # yes, we don't want the 'r' prefix! + rb"\0", + rb"\00", + rb"\00Z", + rb"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + rb"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + rb"\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255.\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255.\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255.\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255", + ] for t in good: try: dns.name.from_text(t) @@ -102,11 +102,13 @@ class NameTestCase(unittest.TestCase): def testImmutable1(self): def bad(): self.origin.labels = () + self.assertRaises(TypeError, bad) def testImmutable2(self): def bad(): - self.origin.labels[0] = 'foo' # type: ignore + self.origin.labels[0] = "foo" # type: ignore + self.assertRaises(TypeError, bad) def testAbs1(self): @@ -119,19 +121,19 @@ class NameTestCase(unittest.TestCase): self.assertTrue(self.origin.is_absolute()) def testAbs4(self): - n = dns.name.from_text('foo', origin=None) + n = dns.name.from_text("foo", origin=None) self.assertFalse(n.is_absolute()) def testWild1(self): - n = dns.name.from_text('*.foo', origin=None) + n = dns.name.from_text("*.foo", origin=None) self.assertTrue(n.is_wild()) def testWild2(self): - n = dns.name.from_text('*a.foo', origin=None) + n = dns.name.from_text("*a.foo", origin=None) self.assertFalse(n.is_wild()) def testWild3(self): - n = dns.name.from_text('a.*.foo', origin=None) + n = dns.name.from_text("a.*.foo", origin=None) self.assertFalse(n.is_wild()) def testWild4(self): @@ -141,21 +143,21 @@ class NameTestCase(unittest.TestCase): self.assertFalse(dns.name.empty.is_wild()) def testHash1(self): - n1 = dns.name.from_text('fOo.COM') - n2 = dns.name.from_text('foo.com') + n1 = dns.name.from_text("fOo.COM") + n2 = dns.name.from_text("foo.com") self.assertEqual(hash(n1), hash(n2)) def testCompare1(self): - n1 = dns.name.from_text('a') - n2 = dns.name.from_text('b') + n1 = dns.name.from_text("a") + n2 = dns.name.from_text("b") self.assertLess(n1, n2) self.assertLessEqual(n1, n2) self.assertGreater(n2, n1) self.assertGreaterEqual(n2, n1) def testCompare2(self): - n1 = dns.name.from_text('') - n2 = dns.name.from_text('b') + n1 = dns.name.from_text("") + n2 = dns.name.from_text("b") self.assertLess(n1, n2) self.assertLessEqual(n1, n2) self.assertGreater(n2, n1) @@ -175,15 +177,15 @@ class NameTestCase(unittest.TestCase): self.assertFalse(dns.name.root.is_subdomain(dns.name.empty)) def testSubdomain3(self): - n = dns.name.from_text('foo', origin=self.origin) + n = dns.name.from_text("foo", origin=self.origin) self.assertTrue(n.is_subdomain(self.origin)) def testSubdomain4(self): - n = dns.name.from_text('foo', origin=self.origin) + n = dns.name.from_text("foo", origin=self.origin) self.assertTrue(n.is_subdomain(dns.name.root)) def testSubdomain5(self): - n = dns.name.from_text('foo', origin=self.origin) + n = dns.name.from_text("foo", origin=self.origin) self.assertTrue(n.is_subdomain(n)) def testSuperdomain1(self): @@ -193,277 +195,286 @@ class NameTestCase(unittest.TestCase): self.assertFalse(dns.name.root.is_superdomain(dns.name.empty)) def testSuperdomain3(self): - n = dns.name.from_text('foo', origin=self.origin) + n = dns.name.from_text("foo", origin=self.origin) self.assertTrue(self.origin.is_superdomain(n)) def testSuperdomain4(self): - n = dns.name.from_text('foo', origin=self.origin) + n = dns.name.from_text("foo", origin=self.origin) self.assertTrue(dns.name.root.is_superdomain(n)) def testSuperdomain5(self): - n = dns.name.from_text('foo', origin=self.origin) + n = dns.name.from_text("foo", origin=self.origin) self.assertTrue(n.is_superdomain(n)) def testCanonicalize1(self): - n = dns.name.from_text('FOO.bar', origin=self.origin) + n = dns.name.from_text("FOO.bar", origin=self.origin) c = n.canonicalize() - self.assertEqual(c.labels, (b'foo', b'bar', b'example', b'')) + self.assertEqual(c.labels, (b"foo", b"bar", b"example", b"")) def testToText1(self): - n = dns.name.from_text('FOO.bar', origin=self.origin) + n = dns.name.from_text("FOO.bar", origin=self.origin) t = n.to_text() - self.assertEqual(t, 'FOO.bar.example.') + self.assertEqual(t, "FOO.bar.example.") def testToText2(self): - n = dns.name.from_text('FOO.bar', origin=self.origin) + n = dns.name.from_text("FOO.bar", origin=self.origin) t = n.to_text(True) - self.assertEqual(t, 'FOO.bar.example') + self.assertEqual(t, "FOO.bar.example") def testToText3(self): - n = dns.name.from_text('FOO.bar', origin=None) + n = dns.name.from_text("FOO.bar", origin=None) t = n.to_text() - self.assertEqual(t, 'FOO.bar') + self.assertEqual(t, "FOO.bar") def testToText4(self): t = dns.name.empty.to_text() - self.assertEqual(t, '@') + self.assertEqual(t, "@") def testToText5(self): t = dns.name.root.to_text() - self.assertEqual(t, '.') + self.assertEqual(t, ".") def testToText6(self): - n = dns.name.from_text('FOO bar', origin=None) + n = dns.name.from_text("FOO bar", origin=None) t = n.to_text() - self.assertEqual(t, r'FOO\032bar') + self.assertEqual(t, r"FOO\032bar") def testToText7(self): - n = dns.name.from_text(r'FOO\.bar', origin=None) + n = dns.name.from_text(r"FOO\.bar", origin=None) t = n.to_text() - self.assertEqual(t, r'FOO\.bar') + self.assertEqual(t, r"FOO\.bar") def testToText8(self): - n = dns.name.from_text(r'\070OO\.bar', origin=None) + n = dns.name.from_text(r"\070OO\.bar", origin=None) t = n.to_text() - self.assertEqual(t, r'FOO\.bar') + self.assertEqual(t, r"FOO\.bar") def testToText9(self): - n = dns.name.from_text('FOO bar', origin=None) + n = dns.name.from_text("FOO bar", origin=None) t = n.to_unicode() - self.assertEqual(t, 'FOO\\032bar') + self.assertEqual(t, "FOO\\032bar") def testToText10(self): t = dns.name.empty.to_unicode() - self.assertEqual(t, '@') + self.assertEqual(t, "@") def testToText11(self): t = dns.name.root.to_unicode() - self.assertEqual(t, '.') + self.assertEqual(t, ".") def testToText12(self): - n = dns.name.from_text(r'a\.b.c') + n = dns.name.from_text(r"a\.b.c") t = n.to_unicode() - self.assertEqual(t, r'a\.b.c.') + self.assertEqual(t, r"a\.b.c.") def testToText13(self): - n = dns.name.from_text(r'\150\151\152\153\154\155\156\157\158\159.') + n = dns.name.from_text(r"\150\151\152\153\154\155\156\157\158\159.") t = n.to_text() - self.assertEqual(t, r'\150\151\152\153\154\155\156\157\158\159.') + self.assertEqual(t, r"\150\151\152\153\154\155\156\157\158\159.") def testToText14(self): # Something that didn't start as unicode should go to escapes and not # raise due to interpreting arbitrary binary DNS labels as UTF-8. - n = dns.name.from_text(r'\150\151\152\153\154\155\156\157\158\159.') + n = dns.name.from_text(r"\150\151\152\153\154\155\156\157\158\159.") t = n.to_unicode() - self.assertEqual(t, r'\150\151\152\153\154\155\156\157\158\159.') + self.assertEqual(t, r"\150\151\152\153\154\155\156\157\158\159.") def testSlice1(self): - n = dns.name.from_text(r'a.b.c.', origin=None) + n = dns.name.from_text(r"a.b.c.", origin=None) s = n[:] - self.assertEqual(s, (b'a', b'b', b'c', b'')) + self.assertEqual(s, (b"a", b"b", b"c", b"")) def testSlice2(self): - n = dns.name.from_text(r'a.b.c.', origin=None) + n = dns.name.from_text(r"a.b.c.", origin=None) s = n[:2] - self.assertEqual(s, (b'a', b'b')) + self.assertEqual(s, (b"a", b"b")) def testSlice3(self): - n = dns.name.from_text(r'a.b.c.', origin=None) + n = dns.name.from_text(r"a.b.c.", origin=None) s = n[2:] - self.assertEqual(s, (b'c', b'')) + self.assertEqual(s, (b"c", b"")) def testEmptyLabel1(self): def bad(): - dns.name.Name(['a', '', 'b']) + dns.name.Name(["a", "", "b"]) + self.assertRaises(dns.name.EmptyLabel, bad) def testEmptyLabel2(self): def bad(): - dns.name.Name(['', 'b']) + dns.name.Name(["", "b"]) + self.assertRaises(dns.name.EmptyLabel, bad) def testEmptyLabel3(self): - n = dns.name.Name(['b', '']) + n = dns.name.Name(["b", ""]) self.assertTrue(n) def testLongLabel(self): - n = dns.name.Name(['a' * 63]) + n = dns.name.Name(["a" * 63]) self.assertTrue(n) def testLabelTooLong(self): def bad(): - dns.name.Name(['a' * 64, 'b']) + dns.name.Name(["a" * 64, "b"]) + self.assertRaises(dns.name.LabelTooLong, bad) def testLongName(self): - n = dns.name.Name(['a' * 63, 'a' * 63, 'a' * 63, 'a' * 62]) + n = dns.name.Name(["a" * 63, "a" * 63, "a" * 63, "a" * 62]) self.assertTrue(n) def testNameTooLong(self): def bad(): - dns.name.Name(['a' * 63, 'a' * 63, 'a' * 63, 'a' * 63]) + dns.name.Name(["a" * 63, "a" * 63, "a" * 63, "a" * 63]) + self.assertRaises(dns.name.NameTooLong, bad) def testConcat1(self): - n1 = dns.name.Name(['a', 'b']) - n2 = dns.name.Name(['c', 'd']) - e = dns.name.Name(['a', 'b', 'c', 'd']) + n1 = dns.name.Name(["a", "b"]) + n2 = dns.name.Name(["c", "d"]) + e = dns.name.Name(["a", "b", "c", "d"]) r = n1 + n2 self.assertEqual(r, e) def testConcat2(self): - n1 = dns.name.Name(['a', 'b']) + n1 = dns.name.Name(["a", "b"]) n2 = dns.name.Name([]) - e = dns.name.Name(['a', 'b']) + e = dns.name.Name(["a", "b"]) r = n1 + n2 self.assertEqual(r, e) def testConcat3(self): n1 = dns.name.Name([]) - n2 = dns.name.Name(['a', 'b']) - e = dns.name.Name(['a', 'b']) + n2 = dns.name.Name(["a", "b"]) + e = dns.name.Name(["a", "b"]) r = n1 + n2 self.assertEqual(r, e) def testConcat4(self): - n1 = dns.name.Name(['a', 'b', '']) + n1 = dns.name.Name(["a", "b", ""]) n2 = dns.name.Name([]) - e = dns.name.Name(['a', 'b', '']) + e = dns.name.Name(["a", "b", ""]) r = n1 + n2 self.assertEqual(r, e) def testConcat5(self): - n1 = dns.name.Name(['a', 'b']) - n2 = dns.name.Name(['c', '']) - e = dns.name.Name(['a', 'b', 'c', '']) + n1 = dns.name.Name(["a", "b"]) + n2 = dns.name.Name(["c", ""]) + e = dns.name.Name(["a", "b", "c", ""]) r = n1 + n2 self.assertEqual(r, e) def testConcat6(self): def bad(): - n1 = dns.name.Name(['a', 'b', '']) - n2 = dns.name.Name(['c']) + n1 = dns.name.Name(["a", "b", ""]) + n2 = dns.name.Name(["c"]) return n1 + n2 + self.assertRaises(dns.name.AbsoluteConcatenation, bad) def testBadEscape(self): def bad(): - n = dns.name.from_text(r'a.b\0q1.c.') + n = dns.name.from_text(r"a.b\0q1.c.") + self.assertRaises(dns.name.BadEscape, bad) def testDigestable1(self): - n = dns.name.from_text('FOO.bar') + n = dns.name.from_text("FOO.bar") d = n.to_digestable() - self.assertEqual(d, b'\x03foo\x03bar\x00') + self.assertEqual(d, b"\x03foo\x03bar\x00") def testDigestable2(self): - n1 = dns.name.from_text('FOO.bar') - n2 = dns.name.from_text('foo.BAR.') + n1 = dns.name.from_text("FOO.bar") + n2 = dns.name.from_text("foo.BAR.") d1 = n1.to_digestable() d2 = n2.to_digestable() self.assertEqual(d1, d2) def testDigestable3(self): d = dns.name.root.to_digestable() - self.assertEqual(d, b'\x00') + self.assertEqual(d, b"\x00") def testDigestable4(self): - n = dns.name.from_text('FOO.bar', None) + n = dns.name.from_text("FOO.bar", None) d = n.to_digestable(dns.name.root) - self.assertEqual(d, b'\x03foo\x03bar\x00') + self.assertEqual(d, b"\x03foo\x03bar\x00") def testBadDigestable(self): def bad(): - n = dns.name.from_text('FOO.bar', None) + n = dns.name.from_text("FOO.bar", None) n.to_digestable() + self.assertRaises(dns.name.NeedAbsoluteNameOrOrigin, bad) def testToWire1(self): - n = dns.name.from_text('FOO.bar') + n = dns.name.from_text("FOO.bar") f = BytesIO() - compress = {} # type: Dict[dns.name.Name,int] + compress = {} # type: Dict[dns.name.Name,int] n.to_wire(f, compress) - self.assertEqual(f.getvalue(), b'\x03FOO\x03bar\x00') + self.assertEqual(f.getvalue(), b"\x03FOO\x03bar\x00") def testToWire2(self): - n = dns.name.from_text('FOO.bar') + n = dns.name.from_text("FOO.bar") f = BytesIO() - compress = {} # type: Dict[dns.name.Name,int] + compress = {} # type: Dict[dns.name.Name,int] n.to_wire(f, compress) n.to_wire(f, compress) - self.assertEqual(f.getvalue(), b'\x03FOO\x03bar\x00\xc0\x00') + self.assertEqual(f.getvalue(), b"\x03FOO\x03bar\x00\xc0\x00") def testToWire3(self): - n1 = dns.name.from_text('FOO.bar') - n2 = dns.name.from_text('foo.bar') + n1 = dns.name.from_text("FOO.bar") + n2 = dns.name.from_text("foo.bar") f = BytesIO() - compress = {} # type: Dict[dns.name.Name,int] + compress = {} # type: Dict[dns.name.Name,int] n1.to_wire(f, compress) n2.to_wire(f, compress) - self.assertEqual(f.getvalue(), b'\x03FOO\x03bar\x00\xc0\x00') + self.assertEqual(f.getvalue(), b"\x03FOO\x03bar\x00\xc0\x00") def testToWire4(self): - n1 = dns.name.from_text('FOO.bar') - n2 = dns.name.from_text('a.foo.bar') + n1 = dns.name.from_text("FOO.bar") + n2 = dns.name.from_text("a.foo.bar") f = BytesIO() - compress = {} # type: Dict[dns.name.Name,int] + compress = {} # type: Dict[dns.name.Name,int] n1.to_wire(f, compress) n2.to_wire(f, compress) - self.assertEqual(f.getvalue(), b'\x03FOO\x03bar\x00\x01\x61\xc0\x00') + self.assertEqual(f.getvalue(), b"\x03FOO\x03bar\x00\x01\x61\xc0\x00") def testToWire5(self): - n1 = dns.name.from_text('FOO.bar') - n2 = dns.name.from_text('a.foo.bar') + n1 = dns.name.from_text("FOO.bar") + n2 = dns.name.from_text("a.foo.bar") f = BytesIO() - compress = {} # type: Dict[dns.name.Name,int] + compress = {} # type: Dict[dns.name.Name,int] n1.to_wire(f, compress) n2.to_wire(f, None) - self.assertEqual(f.getvalue(), - b'\x03FOO\x03bar\x00\x01\x61\x03foo\x03bar\x00') + self.assertEqual(f.getvalue(), b"\x03FOO\x03bar\x00\x01\x61\x03foo\x03bar\x00") def testToWire6(self): - n = dns.name.from_text('FOO.bar') + n = dns.name.from_text("FOO.bar") v = n.to_wire() - self.assertEqual(v, b'\x03FOO\x03bar\x00') + self.assertEqual(v, b"\x03FOO\x03bar\x00") def testToWireRelativeNameWithOrigin(self): - n = dns.name.from_text('FOO', None) - o = dns.name.from_text('bar') + n = dns.name.from_text("FOO", None) + o = dns.name.from_text("bar") v = n.to_wire(origin=o) - self.assertEqual(v, b'\x03FOO\x03bar\x00') + self.assertEqual(v, b"\x03FOO\x03bar\x00") def testToWireRelativeNameWithoutOrigin(self): - n = dns.name.from_text('FOO', None) + n = dns.name.from_text("FOO", None) + def bad(): v = n.to_wire() + self.assertRaises(dns.name.NeedAbsoluteNameOrOrigin, bad) def testBadToWire(self): def bad(): - n = dns.name.from_text('FOO.bar', None) + n = dns.name.from_text("FOO.bar", None) f = BytesIO() - compress = {} # type: Dict[dns.name.Name,int] + compress = {} # type: Dict[dns.name.Name,int] n.to_wire(f, compress) + self.assertRaises(dns.name.NeedAbsoluteNameOrOrigin, bad) def testGiantCompressionTable(self): @@ -471,14 +482,14 @@ class NameTestCase(unittest.TestCase): f = BytesIO() compress = {} # type: Dict[dns.name.Name,int] # exactly 16 bytes encoded - n = dns.name.from_text('0000000000.com.') + n = dns.name.from_text("0000000000.com.") n.to_wire(f, compress) # There are now two entries in the compression table (for the full # name, and for the com. suffix. self.assertEqual(len(compress), 2) for i in range(1023): # exactly 16 bytes encoded with compression - n = dns.name.from_text(f'{i:013d}.com') + n = dns.name.from_text(f"{i:013d}.com") n.to_wire(f, compress) # There are now 1025 entries in the compression table with # the last entry at offset 16368. @@ -486,143 +497,145 @@ class NameTestCase(unittest.TestCase): self.assertEqual(compress[n], 16368) # Adding another name should not increase the size of the compression # table, as the pointer would be at offset 16384, which is too big. - n = dns.name.from_text('toobig.com.') + n = dns.name.from_text("toobig.com.") n.to_wire(f, compress) self.assertEqual(len(compress), 1025) def testSplit1(self): - n = dns.name.from_text('foo.bar.') + n = dns.name.from_text("foo.bar.") (prefix, suffix) = n.split(2) - ep = dns.name.from_text('foo', None) - es = dns.name.from_text('bar.', None) + ep = dns.name.from_text("foo", None) + es = dns.name.from_text("bar.", None) self.assertEqual(prefix, ep) self.assertEqual(suffix, es) def testSplit2(self): - n = dns.name.from_text('foo.bar.') + n = dns.name.from_text("foo.bar.") (prefix, suffix) = n.split(1) - ep = dns.name.from_text('foo.bar', None) - es = dns.name.from_text('.', None) + ep = dns.name.from_text("foo.bar", None) + es = dns.name.from_text(".", None) self.assertEqual(prefix, ep) self.assertEqual(suffix, es) def testSplit3(self): - n = dns.name.from_text('foo.bar.') + n = dns.name.from_text("foo.bar.") (prefix, suffix) = n.split(0) - ep = dns.name.from_text('foo.bar.', None) - es = dns.name.from_text('', None) + ep = dns.name.from_text("foo.bar.", None) + es = dns.name.from_text("", None) self.assertEqual(prefix, ep) self.assertEqual(suffix, es) def testSplit4(self): - n = dns.name.from_text('foo.bar.') + n = dns.name.from_text("foo.bar.") (prefix, suffix) = n.split(3) - ep = dns.name.from_text('', None) - es = dns.name.from_text('foo.bar.', None) + ep = dns.name.from_text("", None) + es = dns.name.from_text("foo.bar.", None) self.assertEqual(prefix, ep) self.assertEqual(suffix, es) def testBadSplit1(self): def bad(): - n = dns.name.from_text('foo.bar.') + n = dns.name.from_text("foo.bar.") n.split(-1) + self.assertRaises(ValueError, bad) def testBadSplit2(self): def bad(): - n = dns.name.from_text('foo.bar.') + n = dns.name.from_text("foo.bar.") n.split(4) + self.assertRaises(ValueError, bad) def testRelativize1(self): - n = dns.name.from_text('a.foo.bar.', None) - o = dns.name.from_text('bar.', None) - e = dns.name.from_text('a.foo', None) + n = dns.name.from_text("a.foo.bar.", None) + o = dns.name.from_text("bar.", None) + e = dns.name.from_text("a.foo", None) self.assertEqual(n.relativize(o), e) def testRelativize2(self): - n = dns.name.from_text('a.foo.bar.', None) + n = dns.name.from_text("a.foo.bar.", None) o = n e = dns.name.empty self.assertEqual(n.relativize(o), e) def testRelativize3(self): - n = dns.name.from_text('a.foo.bar.', None) - o = dns.name.from_text('blaz.', None) + n = dns.name.from_text("a.foo.bar.", None) + o = dns.name.from_text("blaz.", None) e = n self.assertEqual(n.relativize(o), e) def testRelativize4(self): - n = dns.name.from_text('a.foo', None) + n = dns.name.from_text("a.foo", None) o = dns.name.root e = n self.assertEqual(n.relativize(o), e) def testDerelativize1(self): - n = dns.name.from_text('a.foo', None) - o = dns.name.from_text('bar.', None) - e = dns.name.from_text('a.foo.bar.', None) + n = dns.name.from_text("a.foo", None) + o = dns.name.from_text("bar.", None) + e = dns.name.from_text("a.foo.bar.", None) self.assertEqual(n.derelativize(o), e) def testDerelativize2(self): n = dns.name.empty - o = dns.name.from_text('a.foo.bar.', None) + o = dns.name.from_text("a.foo.bar.", None) e = o self.assertEqual(n.derelativize(o), e) def testDerelativize3(self): - n = dns.name.from_text('a.foo.bar.', None) - o = dns.name.from_text('blaz.', None) + n = dns.name.from_text("a.foo.bar.", None) + o = dns.name.from_text("blaz.", None) e = n self.assertEqual(n.derelativize(o), e) def testChooseRelativity1(self): - n = dns.name.from_text('a.foo.bar.', None) - o = dns.name.from_text('bar.', None) - e = dns.name.from_text('a.foo', None) + n = dns.name.from_text("a.foo.bar.", None) + o = dns.name.from_text("bar.", None) + e = dns.name.from_text("a.foo", None) self.assertEqual(n.choose_relativity(o, True), e) def testChooseRelativity2(self): - n = dns.name.from_text('a.foo.bar.', None) - o = dns.name.from_text('bar.', None) + n = dns.name.from_text("a.foo.bar.", None) + o = dns.name.from_text("bar.", None) e = n self.assertEqual(n.choose_relativity(o, False), e) def testChooseRelativity3(self): - n = dns.name.from_text('a.foo', None) - o = dns.name.from_text('bar.', None) - e = dns.name.from_text('a.foo.bar.', None) + n = dns.name.from_text("a.foo", None) + o = dns.name.from_text("bar.", None) + e = dns.name.from_text("a.foo.bar.", None) self.assertEqual(n.choose_relativity(o, False), e) def testChooseRelativity4(self): - n = dns.name.from_text('a.foo', None) + n = dns.name.from_text("a.foo", None) o = None e = n self.assertEqual(n.choose_relativity(o, True), e) def testChooseRelativity5(self): - n = dns.name.from_text('a.foo', None) + n = dns.name.from_text("a.foo", None) o = None e = n self.assertEqual(n.choose_relativity(o, False), e) def testChooseRelativity6(self): - n = dns.name.from_text('a.foo.', None) + n = dns.name.from_text("a.foo.", None) o = None e = n self.assertEqual(n.choose_relativity(o, True), e) def testChooseRelativity7(self): - n = dns.name.from_text('a.foo.', None) + n = dns.name.from_text("a.foo.", None) o = None e = n self.assertEqual(n.choose_relativity(o, False), e) def testFromWire1(self): - w = b'\x03foo\x00\xc0\x00' + w = b"\x03foo\x00\xc0\x00" (n1, cused1) = dns.name.from_wire(w, 0) (n2, cused2) = dns.name.from_wire(w, cused1) - en1 = dns.name.from_text('foo.') + en1 = dns.name.from_text("foo.") en2 = en1 ecused1 = 5 ecused2 = 2 @@ -632,16 +645,16 @@ class NameTestCase(unittest.TestCase): self.assertEqual(cused2, ecused2) def testFromWire2(self): - w = b'\x03foo\x00\x01a\xc0\x00\x01b\xc0\x05' + w = b"\x03foo\x00\x01a\xc0\x00\x01b\xc0\x05" current = 0 (n1, cused1) = dns.name.from_wire(w, current) current += cused1 (n2, cused2) = dns.name.from_wire(w, current) current += cused2 (n3, cused3) = dns.name.from_wire(w, current) - en1 = dns.name.from_text('foo.') - en2 = dns.name.from_text('a.foo.') - en3 = dns.name.from_text('b.a.foo.') + en1 = dns.name.from_text("foo.") + en2 = dns.name.from_text("a.foo.") + en3 = dns.name.from_text("b.a.foo.") ecused1 = 5 ecused2 = 4 ecused3 = 4 @@ -654,405 +667,445 @@ class NameTestCase(unittest.TestCase): def testBadFromWire1(self): def bad(): - w = b'\x03foo\xc0\x04' + w = b"\x03foo\xc0\x04" dns.name.from_wire(w, 0) + self.assertRaises(dns.name.BadPointer, bad) def testBadFromWire2(self): def bad(): - w = b'\x03foo\xc0\x05' + w = b"\x03foo\xc0\x05" dns.name.from_wire(w, 0) + self.assertRaises(dns.name.BadPointer, bad) def testBadFromWire3(self): def bad(): - w = b'\xbffoo' + w = b"\xbffoo" dns.name.from_wire(w, 0) + self.assertRaises(dns.name.BadLabelType, bad) def testBadFromWire4(self): def bad(): - w = b'\x41foo' + w = b"\x41foo" dns.name.from_wire(w, 0) + self.assertRaises(dns.name.BadLabelType, bad) def testParent1(self): - n = dns.name.from_text('foo.bar.') - self.assertEqual(n.parent(), dns.name.from_text('bar.')) + n = dns.name.from_text("foo.bar.") + self.assertEqual(n.parent(), dns.name.from_text("bar.")) self.assertEqual(n.parent().parent(), dns.name.root) def testParent2(self): - n = dns.name.from_text('foo.bar', None) - self.assertEqual(n.parent(), dns.name.from_text('bar', None)) + n = dns.name.from_text("foo.bar", None) + self.assertEqual(n.parent(), dns.name.from_text("bar", None)) self.assertEqual(n.parent().parent(), dns.name.empty) def testParent3(self): def bad(): n = dns.name.root n.parent() + self.assertRaises(dns.name.NoParent, bad) def testParent4(self): def bad(): n = dns.name.empty n.parent() + self.assertRaises(dns.name.NoParent, bad) def testFromUnicode1(self): - n = dns.name.from_text('foo.bar') - self.assertEqual(n.labels, (b'foo', b'bar', b'')) + n = dns.name.from_text("foo.bar") + self.assertEqual(n.labels, (b"foo", b"bar", b"")) def testFromUnicode2(self): - n = dns.name.from_text('foo\u1234bar.bar') - self.assertEqual(n.labels, (b'xn--foobar-r5z', b'bar', b'')) + n = dns.name.from_text("foo\u1234bar.bar") + self.assertEqual(n.labels, (b"xn--foobar-r5z", b"bar", b"")) def testFromUnicodeAlternateDot1(self): - n = dns.name.from_text('foo\u3002bar') - self.assertEqual(n.labels, (b'foo', b'bar', b'')) + n = dns.name.from_text("foo\u3002bar") + self.assertEqual(n.labels, (b"foo", b"bar", b"")) def testFromUnicodeAlternateDot2(self): - n = dns.name.from_text('foo\uff0ebar') - self.assertEqual(n.labels, (b'foo', b'bar', b'')) + n = dns.name.from_text("foo\uff0ebar") + self.assertEqual(n.labels, (b"foo", b"bar", b"")) def testFromUnicodeAlternateDot3(self): - n = dns.name.from_text('foo\uff61bar') - self.assertEqual(n.labels, (b'foo', b'bar', b'')) + n = dns.name.from_text("foo\uff61bar") + self.assertEqual(n.labels, (b"foo", b"bar", b"")) def testFromUnicodeRoot(self): - n = dns.name.from_text('.') - self.assertEqual(n.labels, (b'',)) + n = dns.name.from_text(".") + self.assertEqual(n.labels, (b"",)) def testFromUnicodeAlternateRoot1(self): - n = dns.name.from_text('\u3002') - self.assertEqual(n.labels, (b'',)) + n = dns.name.from_text("\u3002") + self.assertEqual(n.labels, (b"",)) def testFromUnicodeAlternateRoot2(self): - n = dns.name.from_text('\uff0e') - self.assertEqual(n.labels, (b'',)) + n = dns.name.from_text("\uff0e") + self.assertEqual(n.labels, (b"",)) def testFromUnicodeAlternateRoot3(self): - n = dns.name.from_text('\uff61') - self.assertEqual(n.labels, (b'', )) + n = dns.name.from_text("\uff61") + self.assertEqual(n.labels, (b"",)) def testFromUnicodeIDNA2003Explicit(self): - t = 'Königsgäßchen' + t = "Königsgäßchen" e = dns.name.from_unicode(t, idna_codec=dns.name.IDNA_2003) - self.assertEqual(str(e), 'xn--knigsgsschen-lcb0w.') + self.assertEqual(str(e), "xn--knigsgsschen-lcb0w.") def testFromUnicodeIDNA2003Default(self): - t = 'Königsgäßchen' + t = "Königsgäßchen" e = dns.name.from_unicode(t) - self.assertEqual(str(e), 'xn--knigsgsschen-lcb0w.') + self.assertEqual(str(e), "xn--knigsgsschen-lcb0w.") - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def testFromUnicodeIDNA2008(self): - t = 'Königsgäßchen' + t = "Königsgäßchen" + def bad(): codec = dns.name.IDNA_2008_Strict return dns.name.from_unicode(t, idna_codec=codec) + self.assertRaises(dns.name.IDNAException, bad) e1 = dns.name.from_unicode(t, idna_codec=dns.name.IDNA_2008) - self.assertEqual(str(e1), 'xn--knigsgchen-b4a3dun.') + self.assertEqual(str(e1), "xn--knigsgchen-b4a3dun.") c2 = dns.name.IDNA_2008_Transitional e2 = dns.name.from_unicode(t, idna_codec=c2) - self.assertEqual(str(e2), 'xn--knigsgsschen-lcb0w.') + self.assertEqual(str(e2), "xn--knigsgsschen-lcb0w.") - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def testFromUnicodeIDNA2008Mixed(self): # the IDN rules for names are very restrictive, disallowing # practical names like '_sip._tcp.Königsgäßchen'. Dnspython # has a "practical" mode which permits labels which are purely # ASCII to go straight through, and thus not invalid useful # things in the real world. - t = '_sip._tcp.Königsgäßchen' + t = "_sip._tcp.Königsgäßchen" + def bad1(): codec = dns.name.IDNA_2008_Strict return dns.name.from_unicode(t, idna_codec=codec) + def bad2(): codec = dns.name.IDNA_2008_UTS_46 return dns.name.from_unicode(t, idna_codec=codec) + def bad3(): codec = dns.name.IDNA_2008_Transitional return dns.name.from_unicode(t, idna_codec=codec) + self.assertRaises(dns.name.IDNAException, bad1) self.assertRaises(dns.name.IDNAException, bad2) self.assertRaises(dns.name.IDNAException, bad3) - e = dns.name.from_unicode(t, - idna_codec=dns.name.IDNA_2008_Practical) - self.assertEqual(str(e), '_sip._tcp.xn--knigsgchen-b4a3dun.') + e = dns.name.from_unicode(t, idna_codec=dns.name.IDNA_2008_Practical) + self.assertEqual(str(e), "_sip._tcp.xn--knigsgchen-b4a3dun.") def testFromUnicodeEscapes(self): - n = dns.name.from_unicode(r'\097.\098.\099.') + n = dns.name.from_unicode(r"\097.\098.\099.") t = n.to_unicode() - self.assertEqual(t, 'a.b.c.') + self.assertEqual(t, "a.b.c.") def testToUnicode1(self): - n = dns.name.from_text('foo.bar') + n = dns.name.from_text("foo.bar") s = n.to_unicode() - self.assertEqual(s, 'foo.bar.') + self.assertEqual(s, "foo.bar.") def testToUnicode2(self): - n = dns.name.from_text('foo\u1234bar.bar') + n = dns.name.from_text("foo\u1234bar.bar") s = n.to_unicode() - self.assertEqual(s, 'foo\u1234bar.bar.') + self.assertEqual(s, "foo\u1234bar.bar.") def testToUnicode3(self): - n = dns.name.from_text('foo.bar') + n = dns.name.from_text("foo.bar") s = n.to_unicode() - self.assertEqual(s, 'foo.bar.') + self.assertEqual(s, "foo.bar.") - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def testToUnicode4(self): - n = dns.name.from_text('ドメイン.テスト', - idna_codec=dns.name.IDNA_2008) + n = dns.name.from_text("ドメイン.テスト", idna_codec=dns.name.IDNA_2008) s = n.to_unicode() - self.assertEqual(str(n), 'xn--eckwd4c7c.xn--zckzah.') - self.assertEqual(s, 'ドメイン.テスト.') + self.assertEqual(str(n), "xn--eckwd4c7c.xn--zckzah.") + self.assertEqual(s, "ドメイン.テスト.") - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def testToUnicode5(self): # Exercise UTS 46 remapping in decode. This doesn't normally happen # as you can see from us having to instantiate the codec as # transitional with strict decoding, not one of our usual choices. codec = dns.name.IDNA2008Codec(True, True, False, True) - n = dns.name.from_text('xn--gro-7ka.com') - self.assertEqual(n.to_unicode(idna_codec=codec), - 'gross.com.') + n = dns.name.from_text("xn--gro-7ka.com") + self.assertEqual(n.to_unicode(idna_codec=codec), "gross.com.") - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def testToUnicode6(self): # Test strict 2008 decoding without UTS 46 - n = dns.name.from_text('xn--gro-7ka.com') - self.assertEqual(n.to_unicode(idna_codec=dns.name.IDNA_2008_Strict), - 'groß.com.') + n = dns.name.from_text("xn--gro-7ka.com") + self.assertEqual( + n.to_unicode(idna_codec=dns.name.IDNA_2008_Strict), "groß.com." + ) def testDefaultDecodeIsJustPunycode(self): # groß.com. in IDNA2008 form, pre-encoded. - n = dns.name.from_text('xn--gro-7ka.com') + n = dns.name.from_text("xn--gro-7ka.com") # output using default codec which just decodes the punycode and # doesn't test for IDNA2003 or IDNA2008. - self.assertEqual(n.to_unicode(), 'groß.com.') + self.assertEqual(n.to_unicode(), "groß.com.") def testStrictINDA2003Decode(self): # groß.com. in IDNA2008 form, pre-encoded. - n = dns.name.from_text('xn--gro-7ka.com') + n = dns.name.from_text("xn--gro-7ka.com") + def bad(): # This throws in IDNA2003 because it doesn't "round trip". n.to_unicode(idna_codec=dns.name.IDNA_2003_Strict) + self.assertRaises(dns.name.IDNAException, bad) def testINDA2008Decode(self): # groß.com. in IDNA2008 form, pre-encoded. - n = dns.name.from_text('xn--gro-7ka.com') - self.assertEqual(n.to_unicode(idna_codec=dns.name.IDNA_2008), - 'groß.com.') + n = dns.name.from_text("xn--gro-7ka.com") + self.assertEqual(n.to_unicode(idna_codec=dns.name.IDNA_2008), "groß.com.") def testToUnicodeOmitFinalDot(self): # groß.com. in IDNA2008 form, pre-encoded. - n = dns.name.from_text('xn--gro-7ka.com') - self.assertEqual(n.to_unicode(True, dns.name.IDNA_2008), - 'groß.com') + n = dns.name.from_text("xn--gro-7ka.com") + self.assertEqual(n.to_unicode(True, dns.name.IDNA_2008), "groß.com") def testIDNA2003Misc(self): - self.assertEqual(dns.name.IDNA_2003.encode(''), b'') - self.assertRaises(dns.name.LabelTooLong, - lambda: dns.name.IDNA_2003.encode('x' * 64)) - - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + self.assertEqual(dns.name.IDNA_2003.encode(""), b"") + self.assertRaises( + dns.name.LabelTooLong, lambda: dns.name.IDNA_2003.encode("x" * 64) + ) + + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def testIDNA2008Misc(self): - self.assertEqual(dns.name.IDNA_2008.encode(''), b'') - self.assertRaises(dns.name.LabelTooLong, - lambda: dns.name.IDNA_2008.encode('x' * 64)) - self.assertRaises(dns.name.LabelTooLong, - lambda: dns.name.IDNA_2008.encode('groß' + 'x' * 60)) + self.assertEqual(dns.name.IDNA_2008.encode(""), b"") + self.assertRaises( + dns.name.LabelTooLong, lambda: dns.name.IDNA_2008.encode("x" * 64) + ) + self.assertRaises( + dns.name.LabelTooLong, lambda: dns.name.IDNA_2008.encode("groß" + "x" * 60) + ) def testReverseIPv4(self): - e = dns.name.from_text('1.0.0.127.in-addr.arpa.') - n = dns.reversename.from_address('127.0.0.1') + e = dns.name.from_text("1.0.0.127.in-addr.arpa.") + n = dns.reversename.from_address("127.0.0.1") self.assertEqual(e, n) def testReverseIPv6(self): - e = dns.name.from_text('1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa.') - n = dns.reversename.from_address('::1') + e = dns.name.from_text( + "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa." + ) + n = dns.reversename.from_address("::1") self.assertEqual(e, n) def testReverseIPv6MappedIpv4(self): - e = dns.name.from_text('1.0.0.127.in-addr.arpa.') - n = dns.reversename.from_address('::ffff:127.0.0.1') + e = dns.name.from_text("1.0.0.127.in-addr.arpa.") + n = dns.reversename.from_address("::ffff:127.0.0.1") self.assertEqual(e, n) def testBadReverseIPv4(self): def bad(): - dns.reversename.from_address('127.0.foo.1') + dns.reversename.from_address("127.0.foo.1") + self.assertRaises(dns.exception.SyntaxError, bad) def testBadReverseIPv6(self): def bad(): - dns.reversename.from_address('::1::1') + dns.reversename.from_address("::1::1") + self.assertRaises(dns.exception.SyntaxError, bad) def testReverseIPv4AlternateOrigin(self): - e = dns.name.from_text('1.0.0.127.foo.bar.') - origin = dns.name.from_text('foo.bar') - n = dns.reversename.from_address('127.0.0.1', v4_origin=origin) + e = dns.name.from_text("1.0.0.127.foo.bar.") + origin = dns.name.from_text("foo.bar") + n = dns.reversename.from_address("127.0.0.1", v4_origin=origin) self.assertEqual(e, n) def testReverseIPv6AlternateOrigin(self): - e = dns.name.from_text('1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.foo.bar.') - origin = dns.name.from_text('foo.bar') - n = dns.reversename.from_address('::1', v6_origin=origin) + e = dns.name.from_text( + "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.foo.bar." + ) + origin = dns.name.from_text("foo.bar") + n = dns.reversename.from_address("::1", v6_origin=origin) self.assertEqual(e, n) def testForwardIPv4(self): - n = dns.name.from_text('1.0.0.127.in-addr.arpa.') - e = '127.0.0.1' + n = dns.name.from_text("1.0.0.127.in-addr.arpa.") + e = "127.0.0.1" text = dns.reversename.to_address(n) self.assertEqual(text, e) def testForwardIPv6(self): - n = dns.name.from_text('1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa.') - e = '::1' + n = dns.name.from_text( + "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa." + ) + e = "::1" text = dns.reversename.to_address(n) self.assertEqual(text, e) def testForwardIPv4AlternateOrigin(self): - n = dns.name.from_text('1.0.0.127.foo.bar.') - e = '127.0.0.1' - origin = dns.name.from_text('foo.bar') + n = dns.name.from_text("1.0.0.127.foo.bar.") + e = "127.0.0.1" + origin = dns.name.from_text("foo.bar") text = dns.reversename.to_address(n, v4_origin=origin) self.assertEqual(text, e) def testForwardIPv6AlternateOrigin(self): - n = dns.name.from_text('1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.foo.bar.') - e = '::1' - origin = dns.name.from_text('foo.bar') + n = dns.name.from_text( + "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.foo.bar." + ) + e = "::1" + origin = dns.name.from_text("foo.bar") text = dns.reversename.to_address(n, v6_origin=origin) self.assertEqual(text, e) def testUnknownReverseOrigin(self): - n = dns.name.from_text('1.2.3.4.unknown.') + n = dns.name.from_text("1.2.3.4.unknown.") with self.assertRaises(dns.exception.SyntaxError): dns.reversename.to_address(n) def testE164ToEnum(self): - text = '+1 650 555 1212' - e = dns.name.from_text('2.1.2.1.5.5.5.0.5.6.1.e164.arpa.') + text = "+1 650 555 1212" + e = dns.name.from_text("2.1.2.1.5.5.5.0.5.6.1.e164.arpa.") n = dns.e164.from_e164(text) self.assertEqual(n, e) def testEnumToE164(self): - n = dns.name.from_text('2.1.2.1.5.5.5.0.5.6.1.e164.arpa.') - e = '+16505551212' + n = dns.name.from_text("2.1.2.1.5.5.5.0.5.6.1.e164.arpa.") + e = "+16505551212" text = dns.e164.to_e164(n) self.assertEqual(text, e) def testBadEnumToE164(self): - n = dns.name.from_text('2.1.2.q.5.5.5.0.5.6.1.e164.arpa.') - self.assertRaises(dns.exception.SyntaxError, - lambda: dns.e164.to_e164(n)) + n = dns.name.from_text("2.1.2.q.5.5.5.0.5.6.1.e164.arpa.") + self.assertRaises(dns.exception.SyntaxError, lambda: dns.e164.to_e164(n)) def test_incompatible_relations(self): - n1 = dns.name.from_text('example') - n2 = 'abc' + n1 = dns.name.from_text("example") + n2 = "abc" for oper in [operator.lt, operator.le, operator.ge, operator.gt]: self.assertRaises(TypeError, lambda: oper(n1, n2)) self.assertFalse(n1 == n2) self.assertTrue(n1 != n2) def testFromUnicodeSimpleEscape(self): - n = dns.name.from_unicode(r'a.\b') - e = dns.name.from_unicode(r'a.b') + n = dns.name.from_unicode(r"a.\b") + e = dns.name.from_unicode(r"a.b") self.assertEqual(n, e) def testFromUnicodeBadEscape(self): def bad1(): - n = dns.name.from_unicode(r'a.b\0q1.c.') + n = dns.name.from_unicode(r"a.b\0q1.c.") + self.assertRaises(dns.name.BadEscape, bad1) + def bad2(): - n = dns.name.from_unicode(r'a.b\0') + n = dns.name.from_unicode(r"a.b\0") + self.assertRaises(dns.name.BadEscape, bad2) def testFromUnicodeNotString(self): def bad(): - dns.name.from_unicode(b'123') # type: ignore + dns.name.from_unicode(b"123") # type: ignore + self.assertRaises(ValueError, bad) def testFromUnicodeBadOrigin(self): def bad(): - dns.name.from_unicode('example', 123) # type: ignore + dns.name.from_unicode("example", 123) # type: ignore + self.assertRaises(ValueError, bad) def testFromUnicodeEmptyLabel(self): def bad(): - dns.name.from_unicode('a..b.example') + dns.name.from_unicode("a..b.example") + self.assertRaises(dns.name.EmptyLabel, bad) def testFromUnicodeEmptyName(self): - self.assertEqual(dns.name.from_unicode('@', None), dns.name.empty) + self.assertEqual(dns.name.from_unicode("@", None), dns.name.empty) def testFromTextNotString(self): def bad(): dns.name.from_text(123) # type: ignore + self.assertRaises(ValueError, bad) def testFromTextBadOrigin(self): def bad(): - dns.name.from_text('example', 123) # type: ignore + dns.name.from_text("example", 123) # type: ignore + self.assertRaises(ValueError, bad) def testFromWireNotBytes(self): def bad(): dns.name.from_wire(123, 0) # type: ignore + self.assertRaises(ValueError, bad) def testBadPunycode(self): c = dns.name.IDNACodec() with self.assertRaises(dns.name.IDNAException): - c.decode(b'xn--0000h') + c.decode(b"xn--0000h") def testRootLabel2003StrictDecode(self): c = dns.name.IDNA_2003_Strict - self.assertEqual(c.decode(b''), '') + self.assertEqual(c.decode(b""), "") - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def testRootLabel2008StrictDecode(self): c = dns.name.IDNA_2008_Strict - self.assertEqual(c.decode(b''), '') + self.assertEqual(c.decode(b""), "") - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def testCodecNotFoundRaises(self): dns.name.have_idna_2008 = False with self.assertRaises(dns.name.NoIDNA2008): c = dns.name.IDNA2008Codec() - c.encode('Königsgäßchen') + c.encode("Königsgäßchen") with self.assertRaises(dns.name.NoIDNA2008): c = dns.name.IDNA2008Codec(strict_decode=True) - c.decode(b'xn--eckwd4c7c.xn--zckzah.') + c.decode(b"xn--eckwd4c7c.xn--zckzah.") dns.name.have_idna_2008 = True - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def testBadPunycodeStrict2008(self): c = dns.name.IDNA2008Codec(strict_decode=True) with self.assertRaises(dns.name.IDNAException): - c.decode(b'xn--0000h') + c.decode(b"xn--0000h") def testRelativizeSubtractionSyntax(self): - n = dns.name.from_text('foo.example.') - o = dns.name.from_text('example.') - e = dns.name.from_text('foo', None) + n = dns.name.from_text("foo.example.") + o = dns.name.from_text("example.") + e = dns.name.from_text("foo", None) self.assertEqual(n - o, e) def testCopy(self): - n1 = dns.name.from_text('foo.example.') + n1 = dns.name.from_text("foo.example.") n2 = copy.copy(n1) self.assertTrue(n1 is not n2) # the Name constructor always copies labels, so there is no @@ -1063,7 +1116,7 @@ class NameTestCase(unittest.TestCase): self.assertTrue(l is n2[i]) def testDeepCopy(self): - n1 = dns.name.from_text('foo.example.') + n1 = dns.name.from_text("foo.example.") n2 = copy.deepcopy(n1) self.assertTrue(n1 is not n2) self.assertTrue(n1.labels is not n2.labels) @@ -1072,19 +1125,20 @@ class NameTestCase(unittest.TestCase): self.assertTrue(l is n2[i]) def testNoAttributeDeletion(self): - n = dns.name.from_text('foo.example.') + n = dns.name.from_text("foo.example.") with self.assertRaises(TypeError): del n.labels def testUnicodeEscapify(self): - n = dns.name.from_unicode('Königsgäßchen;\ttext') - self.assertEqual(n.to_unicode(), 'königsgässchen\\;\\009text.') + n = dns.name.from_unicode("Königsgäßchen;\ttext") + self.assertEqual(n.to_unicode(), "königsgässchen\\;\\009text.") def test_pickle(self): - n1 = dns.name.from_text('foo.example') + n1 = dns.name.from_text("foo.example") p = pickle.dumps(n1) n2 = pickle.loads(p) self.assertEqual(n1, n2) -if __name__ == '__main__': + +if __name__ == "__main__": unittest.main() diff --git a/tests/test_namedict.py b/tests/test_namedict.py index 73097a6..c5563e5 100644 --- a/tests/test_namedict.py +++ b/tests/test_namedict.py @@ -20,17 +20,17 @@ import unittest import dns.name import dns.namedict -class NameTestCase(unittest.TestCase): +class NameTestCase(unittest.TestCase): def setUp(self): self.ndict = dns.namedict.NameDict() - n1 = dns.name.from_text('foo.bar.') - n2 = dns.name.from_text('bar.') + n1 = dns.name.from_text("foo.bar.") + n2 = dns.name.from_text("bar.") self.ndict[n1] = 1 self.ndict[n2] = 2 self.rndict = dns.namedict.NameDict() - n1 = dns.name.from_text('foo.bar', None) - n2 = dns.name.from_text('bar', None) + n1 = dns.name.from_text("foo.bar", None) + n2 = dns.name.from_text("bar", None) self.rndict[n1] = 1 self.rndict[n2] = 2 @@ -38,94 +38,97 @@ class NameTestCase(unittest.TestCase): self.assertEqual(self.ndict.max_depth, 3) def testLookup1(self): - k = dns.name.from_text('foo.bar.') + k = dns.name.from_text("foo.bar.") self.assertEqual(self.ndict[k], 1) def testLookup2(self): - k = dns.name.from_text('foo.bar.') + k = dns.name.from_text("foo.bar.") self.assertEqual(self.ndict.get_deepest_match(k)[1], 1) def testLookup3(self): - k = dns.name.from_text('a.b.c.foo.bar.') + k = dns.name.from_text("a.b.c.foo.bar.") self.assertEqual(self.ndict.get_deepest_match(k)[1], 1) def testLookup4(self): - k = dns.name.from_text('a.b.c.bar.') + k = dns.name.from_text("a.b.c.bar.") self.assertEqual(self.ndict.get_deepest_match(k)[1], 2) def testLookup5(self): def bad(): - n = dns.name.from_text('a.b.c.') + n = dns.name.from_text("a.b.c.") self.ndict.get_deepest_match(n) + self.assertRaises(KeyError, bad) def testLookup6(self): def bad(): self.ndict.get_deepest_match(dns.name.empty) + self.assertRaises(KeyError, bad) def testLookup7(self): self.ndict[dns.name.empty] = 100 - n = dns.name.from_text('a.b.c.') + n = dns.name.from_text("a.b.c.") v = self.ndict.get_deepest_match(n)[1] self.assertEqual(v, 100) def testLookup8(self): def bad(): - self.ndict['foo'] = 100 + self.ndict["foo"] = 100 + self.assertRaises(ValueError, bad) def testRelDepth(self): self.assertEqual(self.rndict.max_depth, 2) def testRelLookup1(self): - k = dns.name.from_text('foo.bar', None) + k = dns.name.from_text("foo.bar", None) self.assertEqual(self.rndict[k], 1) def testRelLookup2(self): - k = dns.name.from_text('foo.bar', None) + k = dns.name.from_text("foo.bar", None) self.assertEqual(self.rndict.get_deepest_match(k)[1], 1) def testRelLookup3(self): - k = dns.name.from_text('a.b.c.foo.bar', None) + k = dns.name.from_text("a.b.c.foo.bar", None) self.assertEqual(self.rndict.get_deepest_match(k)[1], 1) def testRelLookup4(self): - k = dns.name.from_text('a.b.c.bar', None) + k = dns.name.from_text("a.b.c.bar", None) self.assertEqual(self.rndict.get_deepest_match(k)[1], 2) def testRelLookup7(self): self.rndict[dns.name.empty] = 100 - n = dns.name.from_text('a.b.c', None) + n = dns.name.from_text("a.b.c", None) v = self.rndict.get_deepest_match(n)[1] self.assertEqual(v, 100) def test_max_depth_increases(self): - n = dns.name.from_text('a.foo.bar.') + n = dns.name.from_text("a.foo.bar.") self.assertEqual(self.ndict.max_depth, 3) self.ndict[n] = 1 self.assertEqual(self.ndict.max_depth, 4) def test_delete_no_max_depth_change(self): self.assertEqual(self.ndict.max_depth, 3) - n = dns.name.from_text('bar.') + n = dns.name.from_text("bar.") del self.ndict[n] self.assertEqual(self.ndict.max_depth, 3) self.assertEqual(self.ndict.get(n), None) def test_delete_max_depth_changes(self): self.assertEqual(self.ndict.max_depth, 3) - n = dns.name.from_text('foo.bar.') + n = dns.name.from_text("foo.bar.") del self.ndict[n] self.assertEqual(self.ndict.max_depth, 2) self.assertEqual(self.ndict.get(n), None) def test_delete_multiple_max_depth_changes(self): self.assertEqual(self.ndict.max_depth, 3) - nr = dns.name.from_text('roo.') + nr = dns.name.from_text("roo.") self.ndict[nr] = 1 - nf = dns.name.from_text('foo.bar.') - nb = dns.name.from_text('bar.bar.') + nf = dns.name.from_text("foo.bar.") + nb = dns.name.from_text("bar.bar.") self.ndict[nb] = 1 self.assertEqual(self.ndict.max_depth, 3) self.assertEqual(self.ndict.max_depth_items, 2) @@ -139,8 +142,8 @@ class NameTestCase(unittest.TestCase): self.assertEqual(self.ndict.get(nb), None) def test_iter(self): - nf = dns.name.from_text('foo.bar.') - nb = dns.name.from_text('bar.') + nf = dns.name.from_text("foo.bar.") + nb = dns.name.from_text("bar.") keys = set([x for x in self.ndict]) self.assertEqual(len(keys), 2) self.assertTrue(nf in keys) @@ -150,12 +153,13 @@ class NameTestCase(unittest.TestCase): self.assertEqual(len(self.ndict), 2) def test_haskey(self): - nf = dns.name.from_text('foo.bar.') - nb = dns.name.from_text('bar.') - nx = dns.name.from_text('x.') + nf = dns.name.from_text("foo.bar.") + nb = dns.name.from_text("bar.") + nx = dns.name.from_text("x.") self.assertTrue(self.ndict.has_key(nf)) self.assertTrue(self.ndict.has_key(nb)) self.assertFalse(self.ndict.has_key(nx)) -if __name__ == '__main__': + +if __name__ == "__main__": unittest.main() diff --git a/tests/test_nsec3.py b/tests/test_nsec3.py index bf7d115..dd86f2c 100644 --- a/tests/test_nsec3.py +++ b/tests/test_nsec3.py @@ -24,25 +24,32 @@ import dns.rdatatype import dns.rdtypes.ANY.TXT import dns.ttl + class NSEC3TestCase(unittest.TestCase): def test_NSEC3_bitmap(self): - rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NSEC3, - u"1 0 100 ABCD SCBCQHKU35969L2A68P3AD59LHF30715 A CAA TYPE65534") - bitmap = bytearray(b'\0' * 32) + rdata = dns.rdata.from_text( + dns.rdataclass.IN, + dns.rdatatype.NSEC3, + "1 0 100 ABCD SCBCQHKU35969L2A68P3AD59LHF30715 A CAA TYPE65534", + ) + bitmap = bytearray(b"\0" * 32) bitmap[31] = bitmap[31] | 2 - self.assertEqual(rdata.windows, ((0, b'@'), - (1, b'@'), # CAA = 257 - (255, bitmap) - )) + self.assertEqual( + rdata.windows, ((0, b"@"), (1, b"@"), (255, bitmap)) # CAA = 257 + ) def test_NSEC3_bad_bitmaps(self): - rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NSEC3, - u"1 0 100 ABCD SCBCQHKU35969L2A68P3AD59LHF30715 A CAA") + rdata = dns.rdata.from_text( + dns.rdataclass.IN, + dns.rdatatype.NSEC3, + "1 0 100 ABCD SCBCQHKU35969L2A68P3AD59LHF30715 A CAA", + ) with self.assertRaises(dns.exception.FormError): copy = bytearray(rdata.to_wire()) copy[-3] = 0 - dns.rdata.from_wire('IN', 'NSEC3', copy, 0, len(copy)) + dns.rdata.from_wire("IN", "NSEC3", copy, 0, len(copy)) + -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/tests/test_nsec3_hash.py b/tests/test_nsec3_hash.py index f7c4337..8cb6792 100644 --- a/tests/test_nsec3_hash.py +++ b/tests/test_nsec3_hash.py @@ -56,10 +56,10 @@ class NSEC3Hash(unittest.TestCase): "aabbccdd", 12, "0p9mhaveqvm6t7vbl5lop2u3t2rp3tom", - dnssec.NSEC3Hash.SHA1 + dnssec.NSEC3Hash.SHA1, ), ("example", "aabbccdd", 12, "0p9mhaveqvm6t7vbl5lop2u3t2rp3tom", "SHA1"), - ("example", "aabbccdd", 12, "0p9mhaveqvm6t7vbl5lop2u3t2rp3tom", "sha1") + ("example", "aabbccdd", 12, "0p9mhaveqvm6t7vbl5lop2u3t2rp3tom", "sha1"), ] def test_hash_function(self): diff --git a/tests/test_ntoaaton.py b/tests/test_ntoaaton.py index 7e30bce..2468486 100644 --- a/tests/test_ntoaaton.py +++ b/tests/test_ntoaaton.py @@ -30,166 +30,181 @@ ntoa4 = dns.ipv4.inet_ntoa aton6 = dns.ipv6.inet_aton ntoa6 = dns.ipv6.inet_ntoa -v4_bad_addrs = ['256.1.1.1', '1.1.1', '1.1.1.1.1', - '+1.1.1.1', '1.1.1.1+', '1..2.3.4', '.1.2.3.4', - '1.2.3.4.'] +v4_bad_addrs = [ + "256.1.1.1", + "1.1.1", + "1.1.1.1.1", + "+1.1.1.1", + "1.1.1.1+", + "1..2.3.4", + ".1.2.3.4", + "1.2.3.4.", +] -class NtoAAtoNTestCase(unittest.TestCase): +class NtoAAtoNTestCase(unittest.TestCase): def test_aton1(self): - a = aton6('::') - self.assertEqual(a, b'\x00' * 16) + a = aton6("::") + self.assertEqual(a, b"\x00" * 16) def test_aton2(self): - a = aton6('::1') - self.assertEqual(a, b'\x00' * 15 + b'\x01') + a = aton6("::1") + self.assertEqual(a, b"\x00" * 15 + b"\x01") def test_aton3(self): - a = aton6('::10.0.0.1') - self.assertEqual(a, b'\x00' * 12 + b'\x0a\x00\x00\x01') + a = aton6("::10.0.0.1") + self.assertEqual(a, b"\x00" * 12 + b"\x0a\x00\x00\x01") def test_aton4(self): - a = aton6('abcd::dcba') - self.assertEqual(a, b'\xab\xcd' + b'\x00' * 12 + b'\xdc\xba') + a = aton6("abcd::dcba") + self.assertEqual(a, b"\xab\xcd" + b"\x00" * 12 + b"\xdc\xba") def test_aton5(self): - a = aton6('1:2:3:4:5:6:7:8') - self.assertEqual(a, - binascii.unhexlify(b'00010002000300040005000600070008')) + a = aton6("1:2:3:4:5:6:7:8") + self.assertEqual(a, binascii.unhexlify(b"00010002000300040005000600070008")) def test_bad_aton1(self): def bad(): - aton6('abcd:dcba') + aton6("abcd:dcba") + self.assertRaises(dns.exception.SyntaxError, bad) def test_bad_aton2(self): def bad(): - aton6('abcd::dcba::1') + aton6("abcd::dcba::1") + self.assertRaises(dns.exception.SyntaxError, bad) def test_bad_aton3(self): def bad(): - aton6('1:2:3:4:5:6:7:8:9') + aton6("1:2:3:4:5:6:7:8:9") + self.assertRaises(dns.exception.SyntaxError, bad) def test_bad_aton4(self): def bad(): - aton4('001.002.003.004') + aton4("001.002.003.004") + self.assertRaises(dns.exception.SyntaxError, bad) def test_aton6(self): - a = aton6('::') - self.assertEqual(a, b'\x00' * 16) + a = aton6("::") + self.assertEqual(a, b"\x00" * 16) def test_aton7(self): - a = aton6('::1') - self.assertEqual(a, b'\x00' * 15 + b'\x01') + a = aton6("::1") + self.assertEqual(a, b"\x00" * 15 + b"\x01") def test_aton8(self): - a = aton6('::10.0.0.1') - self.assertEqual(a, b'\x00' * 12 + b'\x0a\x00\x00\x01') + a = aton6("::10.0.0.1") + self.assertEqual(a, b"\x00" * 12 + b"\x0a\x00\x00\x01") def test_aton9(self): - a = aton6('abcd::dcba') - self.assertEqual(a, b'\xab\xcd' + b'\x00' * 12 + b'\xdc\xba') + a = aton6("abcd::dcba") + self.assertEqual(a, b"\xab\xcd" + b"\x00" * 12 + b"\xdc\xba") def test_ntoa1(self): - b = binascii.unhexlify(b'00010002000300040005000600070008') + b = binascii.unhexlify(b"00010002000300040005000600070008") t = ntoa6(b) - self.assertEqual(t, '1:2:3:4:5:6:7:8') + self.assertEqual(t, "1:2:3:4:5:6:7:8") def test_ntoa2(self): - b = b'\x00' * 16 + b = b"\x00" * 16 t = ntoa6(b) - self.assertEqual(t, '::') + self.assertEqual(t, "::") def test_ntoa3(self): - b = b'\x00' * 15 + b'\x01' + b = b"\x00" * 15 + b"\x01" t = ntoa6(b) - self.assertEqual(t, '::1') + self.assertEqual(t, "::1") def test_ntoa4(self): - b = b'\x80' + b'\x00' * 15 + b = b"\x80" + b"\x00" * 15 t = ntoa6(b) - self.assertEqual(t, '8000::') + self.assertEqual(t, "8000::") def test_ntoa5(self): - b = b'\x01\xcd' + b'\x00' * 12 + b'\x03\xef' + b = b"\x01\xcd" + b"\x00" * 12 + b"\x03\xef" t = ntoa6(b) - self.assertEqual(t, '1cd::3ef') + self.assertEqual(t, "1cd::3ef") def test_ntoa6(self): - b = binascii.unhexlify(b'ffff00000000ffff000000000000ffff') + b = binascii.unhexlify(b"ffff00000000ffff000000000000ffff") t = ntoa6(b) - self.assertEqual(t, 'ffff:0:0:ffff::ffff') + self.assertEqual(t, "ffff:0:0:ffff::ffff") def test_ntoa7(self): - b = binascii.unhexlify(b'00000000ffff000000000000ffffffff') + b = binascii.unhexlify(b"00000000ffff000000000000ffffffff") t = ntoa6(b) - self.assertEqual(t, '0:0:ffff::ffff:ffff') + self.assertEqual(t, "0:0:ffff::ffff:ffff") def test_ntoa8(self): - b = binascii.unhexlify(b'ffff0000ffff00000000ffff00000000') + b = binascii.unhexlify(b"ffff0000ffff00000000ffff00000000") t = ntoa6(b) - self.assertEqual(t, 'ffff:0:ffff::ffff:0:0') + self.assertEqual(t, "ffff:0:ffff::ffff:0:0") def test_ntoa9(self): - b = binascii.unhexlify(b'0000000000000000000000000a000001') + b = binascii.unhexlify(b"0000000000000000000000000a000001") t = ntoa6(b) - self.assertEqual(t, '::10.0.0.1') + self.assertEqual(t, "::10.0.0.1") def test_ntoa10(self): - b = binascii.unhexlify(b'0000000000000000000000010a000001') + b = binascii.unhexlify(b"0000000000000000000000010a000001") t = ntoa6(b) - self.assertEqual(t, '::1:a00:1') + self.assertEqual(t, "::1:a00:1") def test_ntoa11(self): - b = binascii.unhexlify(b'00000000000000000000ffff0a000001') + b = binascii.unhexlify(b"00000000000000000000ffff0a000001") t = ntoa6(b) - self.assertEqual(t, '::ffff:10.0.0.1') + self.assertEqual(t, "::ffff:10.0.0.1") def test_ntoa12(self): - b = binascii.unhexlify(b'000000000000000000000000ffffffff') + b = binascii.unhexlify(b"000000000000000000000000ffffffff") t = ntoa6(b) - self.assertEqual(t, '::255.255.255.255') + self.assertEqual(t, "::255.255.255.255") def test_ntoa13(self): - b = binascii.unhexlify(b'00000000000000000000ffffffffffff') + b = binascii.unhexlify(b"00000000000000000000ffffffffffff") t = ntoa6(b) - self.assertEqual(t, '::ffff:255.255.255.255') + self.assertEqual(t, "::ffff:255.255.255.255") def test_ntoa14(self): - b = binascii.unhexlify(b'0000000000000000000000000001ffff') + b = binascii.unhexlify(b"0000000000000000000000000001ffff") t = ntoa6(b) - self.assertEqual(t, '::0.1.255.255') + self.assertEqual(t, "::0.1.255.255") def test_ntoa15(self): # This exercises the current_len > best_len branch in the <= case. - b = binascii.unhexlify(b'0000ffff00000000ffff00000000ffff') + b = binascii.unhexlify(b"0000ffff00000000ffff00000000ffff") t = ntoa6(b) - self.assertEqual(t, '0:ffff::ffff:0:0:ffff') + self.assertEqual(t, "0:ffff::ffff:0:0:ffff") def test_bad_ntoa1(self): def bad(): - ntoa6(b'') + ntoa6(b"") + self.assertRaises(ValueError, bad) def test_bad_ntoa2(self): def bad(): - ntoa6(b'\x00' * 17) + ntoa6(b"\x00" * 17) + self.assertRaises(ValueError, bad) def test_bad_ntoa3(self): def bad(): - ntoa4(b'\x00' * 5) + ntoa4(b"\x00" * 5) + # Ideally we'd have been consistent and raised ValueError as # we do for IPv6, but oh well! self.assertRaises(dns.exception.SyntaxError, bad) def test_good_v4_aton(self): - pairs = [('1.2.3.4', b'\x01\x02\x03\x04'), - ('255.255.255.255', b'\xff\xff\xff\xff'), - ('0.0.0.0', b'\x00\x00\x00\x00')] + pairs = [ + ("1.2.3.4", b"\x01\x02\x03\x04"), + ("255.255.255.255", b"\xff\xff\xff\xff"), + ("0.0.0.0", b"\x00\x00\x00\x00"), + ] for (t, b) in pairs: b1 = aton4(t) t1 = ntoa4(b1) @@ -200,43 +215,47 @@ class NtoAAtoNTestCase(unittest.TestCase): def make_bad(a): def bad(): return aton4(a) + return bad + for addr in v4_bad_addrs: self.assertRaises(dns.exception.SyntaxError, make_bad(addr)) def test_bad_v6_aton(self): - addrs = ['+::0', '0::0::', '::0::', '1:2:3:4:5:6:7:8:9', - ':::::::'] - embedded = ['::' + x for x in v4_bad_addrs] + addrs = ["+::0", "0::0::", "::0::", "1:2:3:4:5:6:7:8:9", ":::::::"] + embedded = ["::" + x for x in v4_bad_addrs] addrs.extend(embedded) + def make_bad(a): def bad(): x = aton6(a) + return bad + for addr in addrs: self.assertRaises(dns.exception.SyntaxError, make_bad(addr)) def test_rfc5952_section_4_2_2(self): - addr = '2001:db8:0:1:1:1:1:1' + addr = "2001:db8:0:1:1:1:1:1" b1 = aton6(addr) t1 = ntoa6(b1) self.assertEqual(t1, addr) def test_is_mapped(self): - t1 = '2001:db8:0:1:1:1:1:1' - t2 = '::ffff:127.0.0.1' - t3 = '1::ffff:127.0.0.1' + t1 = "2001:db8:0:1:1:1:1:1" + t2 = "::ffff:127.0.0.1" + t3 = "1::ffff:127.0.0.1" self.assertFalse(dns.ipv6.is_mapped(aton6(t1))) self.assertTrue(dns.ipv6.is_mapped(aton6(t2))) self.assertFalse(dns.ipv6.is_mapped(aton6(t3))) def test_is_multicast(self): - t1 = '223.0.0.1' - t2 = '240.0.0.1' - t3 = '224.0.0.1' - t4 = '239.0.0.1' - t5 = 'fe00::1' - t6 = 'ff00::1' + t1 = "223.0.0.1" + t2 = "240.0.0.1" + t3 = "224.0.0.1" + t4 = "239.0.0.1" + t5 = "fe00::1" + t6 = "ff00::1" self.assertFalse(dns.inet.is_multicast(t1)) self.assertFalse(dns.inet.is_multicast(t2)) self.assertTrue(dns.inet.is_multicast(t3)) @@ -246,52 +265,58 @@ class NtoAAtoNTestCase(unittest.TestCase): def test_is_multicast_bad_input(self): def bad(): - dns.inet.is_multicast('hello world') + dns.inet.is_multicast("hello world") + self.assertRaises(ValueError, bad) def test_ignore_scope(self): - t1 = 'fe80::1%lo0' - t2 = 'fe80::1' + t1 = "fe80::1%lo0" + t2 = "fe80::1" self.assertEqual(aton6(t1, True), aton6(t2)) def test_do_not_ignore_scope(self): def bad(): - t1 = 'fe80::1%lo0' + t1 = "fe80::1%lo0" aton6(t1) + self.assertRaises(dns.exception.SyntaxError, bad) def test_multiple_scopes_bad(self): def bad(): - t1 = 'fe80::1%lo0%lo1' + t1 = "fe80::1%lo0%lo1" aton6(t1, True) + self.assertRaises(dns.exception.SyntaxError, bad) def test_ptontop(self): - for (af, a) in [(socket.AF_INET, '1.2.3.4'), - (socket.AF_INET6, '2001:db8:0:1:1:1:1:1')]: - self.assertEqual(dns.inet.inet_ntop(af, dns.inet.inet_pton(af, a)), - a) + for (af, a) in [ + (socket.AF_INET, "1.2.3.4"), + (socket.AF_INET6, "2001:db8:0:1:1:1:1:1"), + ]: + self.assertEqual(dns.inet.inet_ntop(af, dns.inet.inet_pton(af, a)), a) def test_isaddress(self): - for (t, e) in [('1.2.3.4', True), - ('2001:db8:0:1:1:1:1:1', True), - ('hello world', False), - ('http://www.dnspython.org', False), - ('1.2.3.4a', False), - ('2001:db8:0:1:1:1:1:q1', False)]: + for (t, e) in [ + ("1.2.3.4", True), + ("2001:db8:0:1:1:1:1:1", True), + ("hello world", False), + ("http://www.dnspython.org", False), + ("1.2.3.4a", False), + ("2001:db8:0:1:1:1:1:q1", False), + ]: self.assertEqual(dns.inet.is_address(t), e) def test_low_level_address_tuple(self): - t = dns.inet.low_level_address_tuple(('1.2.3.4', 53)) - self.assertEqual(t, ('1.2.3.4', 53)) - t = dns.inet.low_level_address_tuple(('2600::1', 53)) - self.assertEqual(t, ('2600::1', 53, 0, 0)) - t = dns.inet.low_level_address_tuple(('1.2.3.4', 53), socket.AF_INET) - self.assertEqual(t, ('1.2.3.4', 53)) - t = dns.inet.low_level_address_tuple(('2600::1', 53), socket.AF_INET6) - self.assertEqual(t, ('2600::1', 53, 0, 0)) - t = dns.inet.low_level_address_tuple(('fd80::1%2', 53), socket.AF_INET6) - self.assertEqual(t, ('fd80::1', 53, 0, 2)) + t = dns.inet.low_level_address_tuple(("1.2.3.4", 53)) + self.assertEqual(t, ("1.2.3.4", 53)) + t = dns.inet.low_level_address_tuple(("2600::1", 53)) + self.assertEqual(t, ("2600::1", 53, 0, 0)) + t = dns.inet.low_level_address_tuple(("1.2.3.4", 53), socket.AF_INET) + self.assertEqual(t, ("1.2.3.4", 53)) + t = dns.inet.low_level_address_tuple(("2600::1", 53), socket.AF_INET6) + self.assertEqual(t, ("2600::1", 53, 0, 0)) + t = dns.inet.low_level_address_tuple(("fd80::1%2", 53), socket.AF_INET6) + self.assertEqual(t, ("fd80::1", 53, 0, 2)) try: # This can fail on windows for python < 3.8, so we tolerate # the failure and only test if we have something we can work @@ -307,20 +332,24 @@ class NtoAAtoNTestCase(unittest.TestCase): pair = p break if pair: - address = 'fd80::1%' + pair[1] - t = dns.inet.low_level_address_tuple((address, 53), - socket.AF_INET6) - self.assertEqual(t, ('fd80::1', 53, 0, pair[0])) + address = "fd80::1%" + pair[1] + t = dns.inet.low_level_address_tuple((address, 53), socket.AF_INET6) + self.assertEqual(t, ("fd80::1", 53, 0, pair[0])) + def bad(): bogus = socket.AF_INET + socket.AF_INET6 + 1 - t = dns.inet.low_level_address_tuple(('2600::1', 53), bogus) + t = dns.inet.low_level_address_tuple(("2600::1", 53), bogus) + self.assertRaises(NotImplementedError, bad) def test_bogus_family(self): - self.assertRaises(NotImplementedError, - lambda: dns.inet.inet_pton(12345, 'bogus')) - self.assertRaises(NotImplementedError, - lambda: dns.inet.inet_ntop(12345, b'bogus')) + self.assertRaises( + NotImplementedError, lambda: dns.inet.inet_pton(12345, "bogus") + ) + self.assertRaises( + NotImplementedError, lambda: dns.inet.inet_ntop(12345, b"bogus") + ) + -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/tests/test_processing_order.py b/tests/test_processing_order.py index 76754dd..d2025d6 100644 --- a/tests/test_processing_order.py +++ b/tests/test_processing_order.py @@ -1,12 +1,10 @@ - import dns.rdata import dns.rdataset import dns.rdtypes.IN.SRV def test_processing_order_shuffle(): - rds = dns.rdataset.from_text('in', 'a', 300, - '10.0.0.1', '10.0.0.2', '10.0.0.3') + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.1", "10.0.0.2", "10.0.0.3") seen = set() for i in range(100): po = rds.processing_order() @@ -18,8 +16,7 @@ def test_processing_order_shuffle(): def test_processing_order_priority_mx(): - rds = dns.rdataset.from_text('in', 'mx', 300, - '10 a', '20 b', '20 c') + rds = dns.rdataset.from_text("in", "mx", 300, "10 a", "20 b", "20 c") seen = set() for i in range(100): po = rds.processing_order() @@ -32,8 +29,9 @@ def test_processing_order_priority_mx(): def test_processing_order_priority_weighted(): - rds = dns.rdataset.from_text('in', 'srv', 300, - '1 10 1234 a', '2 90 1234 b', '2 10 1234 c') + rds = dns.rdataset.from_text( + "in", "srv", 300, "1 10 1234 a", "2 90 1234 b", "2 10 1234 c" + ) seen = set() weight_90_count = 0 weight_10_count = 0 @@ -58,9 +56,15 @@ def test_processing_order_priority_weighted(): def test_processing_order_priority_naptr(): - rds = dns.rdataset.from_text('in', 'naptr', 300, - '1 10 a b c foo.', '1 20 a b c foo.', - '2 10 a b c foo.', '2 10 d e f bar.') + rds = dns.rdataset.from_text( + "in", + "naptr", + 300, + "1 10 a b c foo.", + "1 20 a b c foo.", + "2 10 a b c foo.", + "2 10 d e f bar.", + ) seen = set() for i in range(100): po = rds.processing_order() @@ -74,26 +78,27 @@ def test_processing_order_priority_naptr(): def test_processing_order_empty(): - rds = dns.rdataset.from_text('in', 'naptr', 300) + rds = dns.rdataset.from_text("in", "naptr", 300) po = rds.processing_order() assert po == [] def test_processing_singleton_priority(): - rds = dns.rdataset.from_text('in', 'mx', 300, '10 a') + rds = dns.rdataset.from_text("in", "mx", 300, "10 a") po = rds.processing_order() assert po == [rds[0]] def test_processing_singleton_weighted(): - rds = dns.rdataset.from_text('in', 'srv', 300, '1 10 1234 a') + rds = dns.rdataset.from_text("in", "srv", 300, "1 10 1234 a") po = rds.processing_order() assert po == [rds[0]] def test_processing_all_zero_weight_srv(): - rds = dns.rdataset.from_text('in', 'srv', 300, - '1 0 1234 a', '1 0 1234 b', '1 0 1234 c') + rds = dns.rdataset.from_text( + "in", "srv", 300, "1 0 1234 a", "1 0 1234 b", "1 0 1234 c" + ) seen = set() for i in range(100): po = rds.processing_order() @@ -108,10 +113,14 @@ def test_processing_order_uri(): # We're testing here just to provide coverage for URI methods; the # testing of the weighting algorithm is done above in tests with # SRV. - rds = dns.rdataset.from_text('in', 'uri', 300, - '1 1 "ftp://ftp1.example.com/public"', - '2 2 "ftp://ftp2.example.com/public"', - '3 3 "ftp://ftp3.example.com/public"') + rds = dns.rdataset.from_text( + "in", + "uri", + 300, + '1 1 "ftp://ftp1.example.com/public"', + '2 2 "ftp://ftp2.example.com/public"', + '3 3 "ftp://ftp3.example.com/public"', + ) po = rds.processing_order() assert len(po) == 3 for i in range(3): @@ -122,10 +131,14 @@ def test_processing_order_svcb(): # We're testing here just to provide coverage for SVCB methods; the # testing of the priority algorithm is done above in tests with # MX and NAPTR. - rds = dns.rdataset.from_text('in', 'svcb', 300, - "1 . mandatory=alpn alpn=h2", - "2 . mandatory=alpn alpn=h2", - "3 . mandatory=alpn alpn=h2") + rds = dns.rdataset.from_text( + "in", + "svcb", + 300, + "1 . mandatory=alpn alpn=h2", + "2 . mandatory=alpn alpn=h2", + "3 . mandatory=alpn alpn=h2", + ) po = rds.processing_order() assert len(po) == 3 for i in range(3): diff --git a/tests/test_query.py b/tests/test_query.py index 2d954e3..e8a5390 100644 --- a/tests/test_query.py +++ b/tests/test_query.py @@ -22,6 +22,7 @@ import unittest try: import ssl + have_ssl = True except Exception: have_ssl = False @@ -40,7 +41,7 @@ import dns.zone # skip those if it's not there. _network_available = True try: - socket.gethostbyname('dnspython.org') + socket.gethostbyname("dnspython.org") except socket.gaierror: _network_available = False @@ -49,16 +50,21 @@ except socket.gaierror: # those tests. try: from .nanonameserver import Server + _nanonameserver_available = True except ImportError: _nanonameserver_available = False + class Server(object): pass + # Probe for IPv4 and IPv6 query_addresses = [] -for (af, address) in ((socket.AF_INET, '8.8.8.8'), - (socket.AF_INET6, '2001:4860:4860::8888')): +for (af, address) in ( + (socket.AF_INET, "8.8.8.8"), + (socket.AF_INET6, "2001:4860:4860::8888"), +): try: with socket.socket(af, socket.SOCK_DGRAM) as s: # Connecting a UDP socket is supposed to return ENETUNREACH if @@ -68,85 +74,93 @@ for (af, address) in ((socket.AF_INET, '8.8.8.8'), except Exception: pass -keyring = dns.tsigkeyring.from_text({'name': 'tDz6cfXXGtNivRpQ98hr6A=='}) +keyring = dns.tsigkeyring.from_text({"name": "tDz6cfXXGtNivRpQ98hr6A=="}) + @unittest.skipIf(not _network_available, "Internet not reachable") class QueryTests(unittest.TestCase): - def testQueryUDP(self): for address in query_addresses: - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") q = dns.message.make_query(qname, dns.rdatatype.A) response = dns.query.udp(q, address, timeout=2) - rrs = response.get_rrset(response.answer, qname, - dns.rdataclass.IN, dns.rdatatype.A) + rrs = response.get_rrset( + response.answer, qname, dns.rdataclass.IN, dns.rdatatype.A + ) self.assertTrue(rrs is not None) seen = set([rdata.address for rdata in rrs]) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) def testQueryUDPWithSocket(self): for address in query_addresses: - with socket.socket(dns.inet.af_for_address(address), - socket.SOCK_DGRAM) as s: + with socket.socket( + dns.inet.af_for_address(address), socket.SOCK_DGRAM + ) as s: s.setblocking(0) - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") q = dns.message.make_query(qname, dns.rdatatype.A) response = dns.query.udp(q, address, sock=s, timeout=2) - rrs = response.get_rrset(response.answer, qname, - dns.rdataclass.IN, dns.rdatatype.A) + rrs = response.get_rrset( + response.answer, qname, dns.rdataclass.IN, dns.rdatatype.A + ) self.assertTrue(rrs is not None) seen = set([rdata.address for rdata in rrs]) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) def testQueryTCP(self): for address in query_addresses: - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") q = dns.message.make_query(qname, dns.rdatatype.A) response = dns.query.tcp(q, address, timeout=2) - rrs = response.get_rrset(response.answer, qname, - dns.rdataclass.IN, dns.rdatatype.A) + rrs = response.get_rrset( + response.answer, qname, dns.rdataclass.IN, dns.rdatatype.A + ) self.assertTrue(rrs is not None) seen = set([rdata.address for rdata in rrs]) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) def testQueryTCPWithSocket(self): for address in query_addresses: - with socket.socket(dns.inet.af_for_address(address), - socket.SOCK_STREAM) as s: + with socket.socket( + dns.inet.af_for_address(address), socket.SOCK_STREAM + ) as s: ll = dns.inet.low_level_address_tuple((address, 53)) s.settimeout(2) s.connect(ll) s.setblocking(0) - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") q = dns.message.make_query(qname, dns.rdatatype.A) response = dns.query.tcp(q, None, sock=s, timeout=2) - rrs = response.get_rrset(response.answer, qname, - dns.rdataclass.IN, dns.rdatatype.A) + rrs = response.get_rrset( + response.answer, qname, dns.rdataclass.IN, dns.rdatatype.A + ) self.assertTrue(rrs is not None) seen = set([rdata.address for rdata in rrs]) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) def testQueryTLS(self): for address in query_addresses: - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") q = dns.message.make_query(qname, dns.rdatatype.A) response = dns.query.tls(q, address, timeout=2) - rrs = response.get_rrset(response.answer, qname, - dns.rdataclass.IN, dns.rdatatype.A) + rrs = response.get_rrset( + response.answer, qname, dns.rdataclass.IN, dns.rdatatype.A + ) self.assertTrue(rrs is not None) seen = set([rdata.address for rdata in rrs]) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) @unittest.skipUnless(have_ssl, "No SSL support") def testQueryTLSWithSocket(self): for address in query_addresses: - with socket.socket(dns.inet.af_for_address(address), - socket.SOCK_STREAM) as base_s: + with socket.socket( + dns.inet.af_for_address(address), socket.SOCK_STREAM + ) as base_s: ll = dns.inet.low_level_address_tuple((address, 853)) base_s.settimeout(2) base_s.connect(ll) @@ -155,21 +169,24 @@ class QueryTests(unittest.TestCase): ctx.minimum_version = ssl.TLSVersion.TLSv1_2 else: ctx.options |= ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1 - with ctx.wrap_socket(base_s, server_hostname='dns.google') as s: # lgtm[py/insecure-protocol] + with ctx.wrap_socket( + base_s, server_hostname="dns.google" + ) as s: # lgtm[py/insecure-protocol] s.setblocking(0) - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") q = dns.message.make_query(qname, dns.rdatatype.A) response = dns.query.tls(q, None, sock=s, timeout=2) - rrs = response.get_rrset(response.answer, qname, - dns.rdataclass.IN, dns.rdatatype.A) + rrs = response.get_rrset( + response.answer, qname, dns.rdataclass.IN, dns.rdatatype.A + ) self.assertTrue(rrs is not None) seen = set([rdata.address for rdata in rrs]) - self.assertTrue('8.8.8.8' in seen) - self.assertTrue('8.8.4.4' in seen) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) def testQueryUDPFallback(self): for address in query_addresses: - qname = dns.name.from_text('.') + qname = dns.name.from_text(".") q = dns.message.make_query(qname, dns.rdatatype.DNSKEY) (_, tcp) = dns.query.udp_with_fallback(q, address, timeout=2) self.assertTrue(tcp) @@ -184,116 +201,120 @@ class QueryTests(unittest.TestCase): tcp_s.settimeout(2) tcp_s.connect(ll) tcp_s.setblocking(0) - qname = dns.name.from_text('.') + qname = dns.name.from_text(".") q = dns.message.make_query(qname, dns.rdatatype.DNSKEY) - (_, tcp) = dns.query.udp_with_fallback(q, address, - udp_sock=udp_s, - tcp_sock=tcp_s, - timeout=2) + (_, tcp) = dns.query.udp_with_fallback( + q, address, udp_sock=udp_s, tcp_sock=tcp_s, timeout=2 + ) self.assertTrue(tcp) def testQueryUDPFallbackNoFallback(self): for address in query_addresses: - qname = dns.name.from_text('dns.google.') + qname = dns.name.from_text("dns.google.") q = dns.message.make_query(qname, dns.rdatatype.A) (_, tcp) = dns.query.udp_with_fallback(q, address, timeout=2) self.assertFalse(tcp) def testUDPReceiveQuery(self): with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as listener: - listener.bind(('127.0.0.1', 0)) + listener.bind(("127.0.0.1", 0)) with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sender: - sender.bind(('127.0.0.1', 0)) - q = dns.message.make_query('dns.google', dns.rdatatype.A) + sender.bind(("127.0.0.1", 0)) + q = dns.message.make_query("dns.google", dns.rdatatype.A) dns.query.send_udp(sender, q, listener.getsockname()) expiration = time.time() + 2 - (q, _, addr) = dns.query.receive_udp(listener, - expiration=expiration) + (q, _, addr) = dns.query.receive_udp(listener, expiration=expiration) self.assertEqual(addr, sender.getsockname()) # for brevity _d_and_s = dns.query._destination_and_source -class DestinationAndSourceTests(unittest.TestCase): +class DestinationAndSourceTests(unittest.TestCase): def test_af_inferred_from_where(self): - (af, d, s) = _d_and_s('1.2.3.4', 53, None, 0) + (af, d, s) = _d_and_s("1.2.3.4", 53, None, 0) self.assertEqual(af, socket.AF_INET) def test_af_inferred_from_where(self): - (af, d, s) = _d_and_s('1::2', 53, None, 0) + (af, d, s) = _d_and_s("1::2", 53, None, 0) self.assertEqual(af, socket.AF_INET6) def test_af_inferred_from_source(self): - (af, d, s) = _d_and_s('https://example/dns-query', 443, - '1.2.3.4', 0, False) + (af, d, s) = _d_and_s("https://example/dns-query", 443, "1.2.3.4", 0, False) self.assertEqual(af, socket.AF_INET) def test_af_mismatch(self): def bad(): - (af, d, s) = _d_and_s('1::2', 53, '1.2.3.4', 0) + (af, d, s) = _d_and_s("1::2", 53, "1.2.3.4", 0) + self.assertRaises(ValueError, bad) def test_source_port_but_no_af_inferred(self): def bad(): - (af, d, s) = _d_and_s('https://example/dns-query', 443, - None, 12345, False) + (af, d, s) = _d_and_s("https://example/dns-query", 443, None, 12345, False) + self.assertRaises(ValueError, bad) def test_where_must_be_an_address(self): def bad(): - (af, d, s) = _d_and_s('not a valid address', 53, '1.2.3.4', 0) + (af, d, s) = _d_and_s("not a valid address", 53, "1.2.3.4", 0) + self.assertRaises(ValueError, bad) def test_destination_is_none_of_where_url(self): - (af, d, s) = _d_and_s('https://example/dns-query', 443, None, 0, False) + (af, d, s) = _d_and_s("https://example/dns-query", 443, None, 0, False) self.assertEqual(d, None) def test_v4_wildcard_source_set(self): - (af, d, s) = _d_and_s('1.2.3.4', 53, None, 12345) - self.assertEqual(s, ('0.0.0.0', 12345)) + (af, d, s) = _d_and_s("1.2.3.4", 53, None, 12345) + self.assertEqual(s, ("0.0.0.0", 12345)) def test_v6_wildcard_source_set(self): - (af, d, s) = _d_and_s('1::2', 53, None, 12345) - self.assertEqual(s, ('::', 12345, 0, 0)) + (af, d, s) = _d_and_s("1::2", 53, None, 12345) + self.assertEqual(s, ("::", 12345, 0, 0)) class AddressesEqualTestCase(unittest.TestCase): - def test_v4(self): - self.assertTrue(dns.query._addresses_equal(socket.AF_INET, - ('10.0.0.1', 53), - ('10.0.0.1', 53))) - self.assertFalse(dns.query._addresses_equal(socket.AF_INET, - ('10.0.0.1', 53), - ('10.0.0.2', 53))) + self.assertTrue( + dns.query._addresses_equal( + socket.AF_INET, ("10.0.0.1", 53), ("10.0.0.1", 53) + ) + ) + self.assertFalse( + dns.query._addresses_equal( + socket.AF_INET, ("10.0.0.1", 53), ("10.0.0.2", 53) + ) + ) def test_v6(self): - self.assertTrue(dns.query._addresses_equal(socket.AF_INET6, - ('1::1', 53), - ('0001:0000::1', 53))) - self.assertFalse(dns.query._addresses_equal(socket.AF_INET6, - ('::1', 53), - ('::2', 53))) + self.assertTrue( + dns.query._addresses_equal( + socket.AF_INET6, ("1::1", 53), ("0001:0000::1", 53) + ) + ) + self.assertFalse( + dns.query._addresses_equal(socket.AF_INET6, ("::1", 53), ("::2", 53)) + ) def test_mixed(self): - self.assertFalse(dns.query._addresses_equal(socket.AF_INET, - ('10.0.0.1', 53), - ('::2', 53))) + self.assertFalse( + dns.query._addresses_equal(socket.AF_INET, ("10.0.0.1", 53), ("::2", 53)) + ) -axfr_zone = ''' +axfr_zone = """ $TTL 300 @ SOA ns1 root 1 7200 900 1209600 86400 @ NS ns1 @ NS ns2 ns1 A 10.0.0.1 ns2 A 10.0.0.1 -''' +""" -class AXFRNanoNameserver(Server): +class AXFRNanoNameserver(Server): def handle(self, request): self.zone = dns.zone.from_text(axfr_zone, origin=self.origin) self.origin = self.zone.origin @@ -307,11 +328,11 @@ class AXFRNanoNameserver(Server): response.question = [] response.flags |= dns.flags.AA for (name, rdataset) in self.zone.iterate_rdatasets(): - if rdataset.rdtype == dns.rdatatype.SOA and \ - name == dns.name.empty: + if rdataset.rdtype == dns.rdatatype.SOA and name == dns.name.empty: continue - rrset = dns.rrset.RRset(name, rdataset.rdclass, rdataset.rdtype, - rdataset.covers) + rrset = dns.rrset.RRset( + name, rdataset.rdclass, rdataset.rdtype, rdataset.covers + ) rrset.update(rdataset) response.answer.append(rrset) items.append(response) @@ -322,7 +343,8 @@ class AXFRNanoNameserver(Server): items.append(response) return items -ixfr_message = '''id 12345 + +ixfr_message = """id 12345 opcode QUERY rcode NOERROR flags AA @@ -340,11 +362,11 @@ example. 300 SOA ns1.example. root.example. 3 7200 900 1209600 86400 example. 300 IN SOA ns1.example. root.example. 4 7200 900 1209600 86400 added2.example. 300 IN A 10.0.0.5 example. 300 IN SOA ns1.example. root.example. 4 7200 900 1209600 86400 -''' +""" -ixfr_trailing_junk = ixfr_message + 'junk.example. 300 IN A 10.0.0.6' +ixfr_trailing_junk = ixfr_message + "junk.example. 300 IN A 10.0.0.6" -ixfr_up_to_date_message = '''id 12345 +ixfr_up_to_date_message = """id 12345 opcode QUERY rcode NOERROR flags AA @@ -352,9 +374,9 @@ flags AA example. IN IXFR ;ANSWER example. 300 IN SOA ns1.example. root.example. 2 7200 900 1209600 86400 -''' +""" -axfr_trailing_junk = '''id 12345 +axfr_trailing_junk = """id 12345 opcode QUERY rcode NOERROR flags AA @@ -367,10 +389,10 @@ added2.example. 300 IN A 10.0.0.5 changed.example. 300 IN A 10.0.0.4 example. 300 IN SOA ns1.example. root.example. 3 7200 900 1209600 86400 junk.example. 300 IN A 10.0.0.6 -''' +""" -class IXFRNanoNameserver(Server): +class IXFRNanoNameserver(Server): def __init__(self, response_text): super().__init__() self.response_text = response_text @@ -383,137 +405,167 @@ class IXFRNanoNameserver(Server): except Exception: pass + @unittest.skipIf(not _nanonameserver_available, "nanonameserver required") class XfrTests(unittest.TestCase): - def test_axfr(self): - expected = dns.zone.from_text(axfr_zone, origin='example') - with AXFRNanoNameserver(origin='example') as ns: - xfr = dns.query.xfr(ns.tcp_address[0], 'example', - port=ns.tcp_address[1]) + expected = dns.zone.from_text(axfr_zone, origin="example") + with AXFRNanoNameserver(origin="example") as ns: + xfr = dns.query.xfr(ns.tcp_address[0], "example", port=ns.tcp_address[1]) zone = dns.zone.from_xfr(xfr) self.assertEqual(zone, expected) def test_axfr_tsig(self): - expected = dns.zone.from_text(axfr_zone, origin='example') - with AXFRNanoNameserver(origin='example', keyring=keyring) as ns: - xfr = dns.query.xfr(ns.tcp_address[0], 'example', - port=ns.tcp_address[1], - keyring=keyring, keyname='name') + expected = dns.zone.from_text(axfr_zone, origin="example") + with AXFRNanoNameserver(origin="example", keyring=keyring) as ns: + xfr = dns.query.xfr( + ns.tcp_address[0], + "example", + port=ns.tcp_address[1], + keyring=keyring, + keyname="name", + ) zone = dns.zone.from_xfr(xfr) self.assertEqual(zone, expected) def test_axfr_root_tsig(self): - expected = dns.zone.from_text(axfr_zone, origin='.') - with AXFRNanoNameserver(origin='.', keyring=keyring) as ns: - xfr = dns.query.xfr(ns.tcp_address[0], '.', - port=ns.tcp_address[1], - keyring=keyring, keyname='name') + expected = dns.zone.from_text(axfr_zone, origin=".") + with AXFRNanoNameserver(origin=".", keyring=keyring) as ns: + xfr = dns.query.xfr( + ns.tcp_address[0], + ".", + port=ns.tcp_address[1], + keyring=keyring, + keyname="name", + ) zone = dns.zone.from_xfr(xfr) self.assertEqual(zone, expected) def test_axfr_udp(self): def bad(): - with AXFRNanoNameserver(origin='example') as ns: - xfr = dns.query.xfr(ns.udp_address[0], 'example', - port=ns.udp_address[1], use_udp=True) + with AXFRNanoNameserver(origin="example") as ns: + xfr = dns.query.xfr( + ns.udp_address[0], "example", port=ns.udp_address[1], use_udp=True + ) l = list(xfr) + self.assertRaises(ValueError, bad) def test_axfr_bad_rcode(self): def bad(): # We just use Server here as by default it will refuse. with Server() as ns: - xfr = dns.query.xfr(ns.tcp_address[0], 'example', - port=ns.tcp_address[1]) + xfr = dns.query.xfr( + ns.tcp_address[0], "example", port=ns.tcp_address[1] + ) l = list(xfr) + self.assertRaises(dns.query.TransferError, bad) def test_axfr_trailing_junk(self): # we use the IXFR server here as it returns messages def bad(): with IXFRNanoNameserver(axfr_trailing_junk) as ns: - xfr = dns.query.xfr(ns.tcp_address[0], 'example', - dns.rdatatype.AXFR, - port=ns.tcp_address[1]) + xfr = dns.query.xfr( + ns.tcp_address[0], + "example", + dns.rdatatype.AXFR, + port=ns.tcp_address[1], + ) l = list(xfr) + self.assertRaises(dns.exception.FormError, bad) def test_ixfr_tcp(self): with IXFRNanoNameserver(ixfr_message) as ns: - xfr = dns.query.xfr(ns.tcp_address[0], 'example', - dns.rdatatype.IXFR, - port=ns.tcp_address[1], - serial=2, - relativize=False) + xfr = dns.query.xfr( + ns.tcp_address[0], + "example", + dns.rdatatype.IXFR, + port=ns.tcp_address[1], + serial=2, + relativize=False, + ) l = list(xfr) self.assertEqual(len(l), 1) - expected = dns.message.from_text(ixfr_message, - one_rr_per_rrset=True) + expected = dns.message.from_text(ixfr_message, one_rr_per_rrset=True) expected.id = l[0].id self.assertEqual(l[0], expected) def test_ixfr_udp(self): with IXFRNanoNameserver(ixfr_message) as ns: - xfr = dns.query.xfr(ns.udp_address[0], 'example', - dns.rdatatype.IXFR, - port=ns.udp_address[1], - serial=2, - relativize=False, use_udp=True) + xfr = dns.query.xfr( + ns.udp_address[0], + "example", + dns.rdatatype.IXFR, + port=ns.udp_address[1], + serial=2, + relativize=False, + use_udp=True, + ) l = list(xfr) self.assertEqual(len(l), 1) - expected = dns.message.from_text(ixfr_message, - one_rr_per_rrset=True) + expected = dns.message.from_text(ixfr_message, one_rr_per_rrset=True) expected.id = l[0].id self.assertEqual(l[0], expected) def test_ixfr_up_to_date(self): with IXFRNanoNameserver(ixfr_up_to_date_message) as ns: - xfr = dns.query.xfr(ns.tcp_address[0], 'example', - dns.rdatatype.IXFR, - port=ns.tcp_address[1], - serial=2, - relativize=False) + xfr = dns.query.xfr( + ns.tcp_address[0], + "example", + dns.rdatatype.IXFR, + port=ns.tcp_address[1], + serial=2, + relativize=False, + ) l = list(xfr) self.assertEqual(len(l), 1) - expected = dns.message.from_text(ixfr_up_to_date_message, - one_rr_per_rrset=True) + expected = dns.message.from_text( + ixfr_up_to_date_message, one_rr_per_rrset=True + ) expected.id = l[0].id self.assertEqual(l[0], expected) def test_ixfr_trailing_junk(self): def bad(): with IXFRNanoNameserver(ixfr_trailing_junk) as ns: - xfr = dns.query.xfr(ns.tcp_address[0], 'example', - dns.rdatatype.IXFR, - port=ns.tcp_address[1], - serial=2, - relativize=False) + xfr = dns.query.xfr( + ns.tcp_address[0], + "example", + dns.rdatatype.IXFR, + port=ns.tcp_address[1], + serial=2, + relativize=False, + ) l = list(xfr) + self.assertRaises(dns.exception.FormError, bad) def test_ixfr_base_serial_mismatch(self): def bad(): with IXFRNanoNameserver(ixfr_message) as ns: - xfr = dns.query.xfr(ns.tcp_address[0], 'example', - dns.rdatatype.IXFR, - port=ns.tcp_address[1], - serial=1, - relativize=False) + xfr = dns.query.xfr( + ns.tcp_address[0], + "example", + dns.rdatatype.IXFR, + port=ns.tcp_address[1], + serial=1, + relativize=False, + ) l = list(xfr) + self.assertRaises(dns.exception.FormError, bad) -class TSIGNanoNameserver(Server): +class TSIGNanoNameserver(Server): def handle(self, request): response = dns.message.make_response(request.message) response.set_rcode(dns.rcode.REFUSED) response.flags |= dns.flags.RA try: - if request.qtype == dns.rdatatype.A and \ - request.qclass == dns.rdataclass.IN: - rrs = dns.rrset.from_text(request.qname, 300, - 'IN', 'A', '1.2.3.4') + if request.qtype == dns.rdatatype.A and request.qclass == dns.rdataclass.IN: + rrs = dns.rrset.from_text(request.qname, 300, "IN", "A", "1.2.3.4") response.answer.append(rrs) response.set_rcode(dns.rcode.NOERROR) response.flags |= dns.flags.AA @@ -521,27 +573,26 @@ class TSIGNanoNameserver(Server): pass return response + @unittest.skipIf(not _nanonameserver_available, "nanonameserver required") class TsigTests(unittest.TestCase): - def test_tsig(self): with TSIGNanoNameserver(keyring=keyring) as ns: - qname = dns.name.from_text('example.com') - q = dns.message.make_query(qname, 'A') - q.use_tsig(keyring=keyring, keyname='name') - response = dns.query.udp(q, ns.udp_address[0], - port=ns.udp_address[1]) + qname = dns.name.from_text("example.com") + q = dns.message.make_query(qname, "A") + q.use_tsig(keyring=keyring, keyname="name") + response = dns.query.udp(q, ns.udp_address[0], port=ns.udp_address[1]) self.assertTrue(response.had_tsig) - rrs = response.get_rrset(response.answer, qname, - dns.rdataclass.IN, dns.rdatatype.A) + rrs = response.get_rrset( + response.answer, qname, dns.rdataclass.IN, dns.rdatatype.A + ) self.assertTrue(rrs is not None) seen = set([rdata.address for rdata in rrs]) - self.assertTrue('1.2.3.4' in seen) + self.assertTrue("1.2.3.4" in seen) -@unittest.skipIf(sys.platform == 'win32', - 'low level tests do not work on win32') -class LowLevelWaitTests(unittest.TestCase): +@unittest.skipIf(sys.platform == "win32", "low level tests do not work on win32") +class LowLevelWaitTests(unittest.TestCase): def test_wait_for(self): try: (l, r) = socket.socketpair() @@ -560,28 +611,32 @@ class LowLevelWaitTests(unittest.TestCase): class MiscTests(unittest.TestCase): def test_matches_destination(self): - self.assertTrue(dns.query._matches_destination(socket.AF_INET, - ('10.0.0.1', 1234), - ('10.0.0.1', 1234), - True)) - self.assertTrue(dns.query._matches_destination(socket.AF_INET6, - ('1::2', 1234), - ('0001::2', 1234), - True)) - self.assertTrue(dns.query._matches_destination(socket.AF_INET, - ('10.0.0.1', 1234), - None, - True)) - self.assertFalse(dns.query._matches_destination(socket.AF_INET, - ('10.0.0.1', 1234), - ('10.0.0.2', 1234), - True)) - self.assertFalse(dns.query._matches_destination(socket.AF_INET, - ('10.0.0.1', 1234), - ('10.0.0.1', 1235), - True)) + self.assertTrue( + dns.query._matches_destination( + socket.AF_INET, ("10.0.0.1", 1234), ("10.0.0.1", 1234), True + ) + ) + self.assertTrue( + dns.query._matches_destination( + socket.AF_INET6, ("1::2", 1234), ("0001::2", 1234), True + ) + ) + self.assertTrue( + dns.query._matches_destination( + socket.AF_INET, ("10.0.0.1", 1234), None, True + ) + ) + self.assertFalse( + dns.query._matches_destination( + socket.AF_INET, ("10.0.0.1", 1234), ("10.0.0.2", 1234), True + ) + ) + self.assertFalse( + dns.query._matches_destination( + socket.AF_INET, ("10.0.0.1", 1234), ("10.0.0.1", 1235), True + ) + ) with self.assertRaises(dns.query.UnexpectedSource): - dns.query._matches_destination(socket.AF_INET, - ('10.0.0.1', 1234), - ('10.0.0.1', 1235), - False) + dns.query._matches_destination( + socket.AF_INET, ("10.0.0.1", 1234), ("10.0.0.1", 1235), False + ) diff --git a/tests/test_rdata.py b/tests/test_rdata.py index c002e7a..a1c066a 100644 --- a/tests/test_rdata.py +++ b/tests/test_rdata.py @@ -44,49 +44,46 @@ import tests.ttxt_module import tests.md_module from tests.util import here -class RdataTestCase(unittest.TestCase): +class RdataTestCase(unittest.TestCase): def test_str(self): - rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - "1.2.3.4") + rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "1.2.3.4") self.assertEqual(rdata.address, "1.2.3.4") def test_unicode(self): - rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - u"1.2.3.4") + rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "1.2.3.4") self.assertEqual(rdata.address, "1.2.3.4") def test_module_registration(self): TTXT = 64001 - dns.rdata.register_type(tests.ttxt_module, TTXT, 'TTXT') - rdata = dns.rdata.from_text(dns.rdataclass.IN, TTXT, 'hello world') - self.assertEqual(rdata.strings, (b'hello', b'world')) - self.assertEqual(dns.rdatatype.to_text(TTXT), 'TTXT') - self.assertEqual(dns.rdatatype.from_text('TTXT'), TTXT) + dns.rdata.register_type(tests.ttxt_module, TTXT, "TTXT") + rdata = dns.rdata.from_text(dns.rdataclass.IN, TTXT, "hello world") + self.assertEqual(rdata.strings, (b"hello", b"world")) + self.assertEqual(dns.rdatatype.to_text(TTXT), "TTXT") + self.assertEqual(dns.rdatatype.from_text("TTXT"), TTXT) def test_module_reregistration(self): def bad(): TTXTTWO = dns.rdatatype.TXT - dns.rdata.register_type(tests.ttxt_module, TTXTTWO, 'TTXTTWO') + dns.rdata.register_type(tests.ttxt_module, TTXTTWO, "TTXTTWO") + self.assertRaises(dns.rdata.RdatatypeExists, bad) def test_module_registration_singleton(self): STXT = 64002 - dns.rdata.register_type(tests.stxt_module, STXT, 'STXT', - is_singleton=True) - rdata1 = dns.rdata.from_text(dns.rdataclass.IN, STXT, 'hello') - rdata2 = dns.rdata.from_text(dns.rdataclass.IN, STXT, 'world') + dns.rdata.register_type(tests.stxt_module, STXT, "STXT", is_singleton=True) + rdata1 = dns.rdata.from_text(dns.rdataclass.IN, STXT, "hello") + rdata2 = dns.rdata.from_text(dns.rdataclass.IN, STXT, "world") rdataset = dns.rdataset.from_rdata(3600, rdata1, rdata2) self.assertEqual(len(rdataset), 1) - self.assertEqual(rdataset[0].strings, (b'world',)) + self.assertEqual(rdataset[0].strings, (b"world",)) def test_replace(self): a1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "1.2.3.4") a2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "2.3.4.5") self.assertEqual(a1.replace(address="2.3.4.5"), a2) - mx = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, - "10 foo.example") + mx = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, "10 foo.example") name = dns.name.from_text("bar.example") self.assertEqual(mx.replace(preference=20).preference, 20) self.assertEqual(mx.replace(preference=20).exchange, mx.exchange) @@ -103,8 +100,7 @@ class RdataTestCase(unittest.TestCase): a1.replace(address="bogus") def test_replace_comment(self): - a1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - "1.2.3.4 ;foo") + a1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "1.2.3.4 ;foo") self.assertEqual(a1.rdcomment, "foo") a2 = a1.replace(rdcomment="bar") self.assertEqual(a1, a2) @@ -120,16 +116,18 @@ class RdataTestCase(unittest.TestCase): def test_to_generic(self): a = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "1.2.3.4") - self.assertEqual(str(a.to_generic()), r'\# 4 01020304') + self.assertEqual(str(a.to_generic()), r"\# 4 01020304") mx = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, "10 foo.") - self.assertEqual(str(mx.to_generic()), r'\# 7 000a03666f6f00') + self.assertEqual(str(mx.to_generic()), r"\# 7 000a03666f6f00") - origin = dns.name.from_text('example') - ns = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - "foo.example.", relativize_to=origin) - self.assertEqual(str(ns.to_generic(origin=origin)), - r'\# 13 03666f6f076578616d706c6500') + origin = dns.name.from_text("example") + ns = dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.NS, "foo.example.", relativize_to=origin + ) + self.assertEqual( + str(ns.to_generic(origin=origin)), r"\# 13 03666f6f076578616d706c6500" + ) def test_txt_unicode(self): # TXT records are not defined for Unicode, but if we get @@ -138,8 +136,9 @@ class RdataTestCase(unittest.TestCase): # to_text(), it does NOT convert embedded UTF-8 back to # Unicode; it's just treated as binary TXT data. Probably # there should be a TXT-like record with an encoding field. - rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.TXT, - '"foo\u200bbar"') + rdata = dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.TXT, '"foo\u200bbar"' + ) self.assertEqual(str(rdata), '"foo\\226\\128\\139bar"') # We used to encode UTF-8 in UTF-8 because we processed # escapes in quoted strings immediately. This meant that the @@ -148,28 +147,35 @@ class RdataTestCase(unittest.TestCase): # point, emitting \\195\\162 instead of \\226, and thus # from_text followed by to_text was not the equal to the # original input like it ought to be. - rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.TXT, - '"foo\\226\\128\\139bar"') + rdata = dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.TXT, '"foo\\226\\128\\139bar"' + ) self.assertEqual(str(rdata), '"foo\\226\\128\\139bar"') # Our fix for TXT-like records uses a new tokenizer method, # unescape_to_bytes(), which converts Unicode to UTF-8 only # once. - rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.TXT, - '"foo\u200b\\123bar"') + rdata = dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.TXT, '"foo\u200b\\123bar"' + ) self.assertEqual(str(rdata), '"foo\\226\\128\\139{bar"') def test_unicode_idna2003_in_rdata(self): - rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - "Königsgäßchen") - self.assertEqual(str(rdata.target), 'xn--knigsgsschen-lcb0w') + rdata = dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.NS, "Königsgäßchen" + ) + self.assertEqual(str(rdata.target), "xn--knigsgsschen-lcb0w") - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def test_unicode_idna2008_in_rdata(self): - rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - "Königsgäßchen", - idna_codec=dns.name.IDNA_2008) - self.assertEqual(str(rdata.target), 'xn--knigsgchen-b4a3dun') + rdata = dns.rdata.from_text( + dns.rdataclass.IN, + dns.rdatatype.NS, + "Königsgäßchen", + idna_codec=dns.name.IDNA_2008, + ) + self.assertEqual(str(rdata.target), "xn--knigsgchen-b4a3dun") def test_digestable_downcasing(self): # Make sure all the types listed in RFC 4034 section 6.2 are @@ -183,32 +189,35 @@ class RdataTestCase(unittest.TestCase): # NSEC3, whose downcasing was removed by RFC 6840 section 5.1 # cases = [ - ('SOA', 'NAME NAME 1 2 3 4 5'), - ('AFSDB', '0 NAME'), - ('CNAME', 'NAME'), - ('DNAME', 'NAME'), - ('KX', '10 NAME'), - ('MX', '10 NAME'), - ('NS', 'NAME'), - ('NAPTR', '0 0 a B c NAME'), - ('PTR', 'NAME'), - ('PX', '65535 NAME NAME'), - ('RP', 'NAME NAME'), - ('RT', '0 NAME'), - ('SRV', '0 0 0 NAME'), - ('RRSIG', - 'A 1 3 3600 20200701000000 20200601000000 1 NAME Ym9ndXM=') + ("SOA", "NAME NAME 1 2 3 4 5"), + ("AFSDB", "0 NAME"), + ("CNAME", "NAME"), + ("DNAME", "NAME"), + ("KX", "10 NAME"), + ("MX", "10 NAME"), + ("NS", "NAME"), + ("NAPTR", "0 0 a B c NAME"), + ("PTR", "NAME"), + ("PX", "65535 NAME NAME"), + ("RP", "NAME NAME"), + ("RT", "0 NAME"), + ("SRV", "0 0 0 NAME"), + ("RRSIG", "A 1 3 3600 20200701000000 20200601000000 1 NAME Ym9ndXM="), ] for rdtype, text in cases: - upper_origin = dns.name.from_text('EXAMPLE') - lower_origin = dns.name.from_text('example') - canonical_text = text.replace('NAME', 'name') - rdata = dns.rdata.from_text(dns.rdataclass.IN, rdtype, text, - origin=upper_origin, relativize=False) - canonical_rdata = dns.rdata.from_text(dns.rdataclass.IN, rdtype, - canonical_text, - origin=lower_origin, - relativize=False) + upper_origin = dns.name.from_text("EXAMPLE") + lower_origin = dns.name.from_text("example") + canonical_text = text.replace("NAME", "name") + rdata = dns.rdata.from_text( + dns.rdataclass.IN, rdtype, text, origin=upper_origin, relativize=False + ) + canonical_rdata = dns.rdata.from_text( + dns.rdataclass.IN, + rdtype, + canonical_text, + origin=lower_origin, + relativize=False, + ) digestable_wire = rdata.to_digestable() f = io.BytesIO() canonical_rdata.to_wire(f) @@ -221,23 +230,22 @@ class RdataTestCase(unittest.TestCase): # handled properly. # cases = [ - ('HIP', '2 200100107B1A74DF365639CC39F1D578 Ym9ndXM= NAME name'), - ('IPSECKEY', '10 3 2 NAME Ym9ndXM='), - ('NSEC', 'NAME A'), + ("HIP", "2 200100107B1A74DF365639CC39F1D578 Ym9ndXM= NAME name"), + ("IPSECKEY", "10 3 2 NAME Ym9ndXM="), + ("NSEC", "NAME A"), ] for rdtype, text in cases: - origin = dns.name.from_text('example') - rdata = dns.rdata.from_text(dns.rdataclass.IN, rdtype, text, - origin=origin, relativize=False) + origin = dns.name.from_text("example") + rdata = dns.rdata.from_text( + dns.rdataclass.IN, rdtype, text, origin=origin, relativize=False + ) digestable_wire = rdata.to_digestable(origin) expected_wire = rdata.to_wire(origin=origin) self.assertEqual(digestable_wire, expected_wire) def test_basic_relations(self): - r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1') - r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2') + r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1") + r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2") self.assertTrue(r1 == r1) self.assertTrue(r1 != r2) self.assertTrue(r1 < r2) @@ -246,10 +254,8 @@ class RdataTestCase(unittest.TestCase): self.assertTrue(r2 >= r1) def test_incompatible_relations(self): - r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1') - r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.AAAA, - '::1') + r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1") + r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.AAAA, "::1") for oper in [operator.lt, operator.le, operator.ge, operator.gt]: self.assertRaises(TypeError, lambda: oper(r1, r2)) self.assertFalse(r1 == r2) @@ -257,32 +263,34 @@ class RdataTestCase(unittest.TestCase): def test_immutability(self): def bad1(): - r = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1') - r.address = '10.0.0.2' + r = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1") + r.address = "10.0.0.2" + self.assertRaises(TypeError, bad1) + def bad2(): - r = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1') + r = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1") del r.address + self.assertRaises(TypeError, bad2) def test_pickle(self): - r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1') + r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1") p = pickle.dumps(r1) r2 = pickle.loads(p) self.assertEqual(r1, r2) # Pickle something with a longer inheritance chain - r3 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, - '10 mail.example.') + r3 = dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.MX, "10 mail.example." + ) p = pickle.dumps(r3) r4 = pickle.loads(p) self.assertEqual(r3, r4) def test_AFSDB_properties(self): - rd = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.AFSDB, - '0 afsdb.example.') + rd = dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.AFSDB, "0 afsdb.example." + ) self.assertEqual(rd.preference, rd.subtype) self.assertEqual(rd.exchange, rd.hostname) @@ -293,93 +301,118 @@ class RdataTestCase(unittest.TestCase): def test_misc_good_LOC_text(self): # test just degrees - self.equal_loc('60 N 24 39 0.000 E 10.00m 20m 2000m 20m', - '60 0 0 N 24 39 0.000 E 10.00m 20m 2000m 20m') - self.equal_loc('60 0 0 N 24 E 10.00m 20m 2000m 20m', - '60 0 0 N 24 0 0 E 10.00m 20m 2000m 20m') + self.equal_loc( + "60 N 24 39 0.000 E 10.00m 20m 2000m 20m", + "60 0 0 N 24 39 0.000 E 10.00m 20m 2000m 20m", + ) + self.equal_loc( + "60 0 0 N 24 E 10.00m 20m 2000m 20m", + "60 0 0 N 24 0 0 E 10.00m 20m 2000m 20m", + ) # test variable length latitude - self.equal_loc('60 9 0.510 N 24 39 0.000 E 10.00m 20m 2000m 20m', - '60 9 0.51 N 24 39 0.000 E 10.00m 20m 2000m 20m') - self.equal_loc('60 9 0.500 N 24 39 0.000 E 10.00m 20m 2000m 20m', - '60 9 0.5 N 24 39 0.000 E 10.00m 20m 2000m 20m') - self.equal_loc('60 9 1.000 N 24 39 0.000 E 10.00m 20m 2000m 20m', - '60 9 1 N 24 39 0.000 E 10.00m 20m 2000m 20m') + self.equal_loc( + "60 9 0.510 N 24 39 0.000 E 10.00m 20m 2000m 20m", + "60 9 0.51 N 24 39 0.000 E 10.00m 20m 2000m 20m", + ) + self.equal_loc( + "60 9 0.500 N 24 39 0.000 E 10.00m 20m 2000m 20m", + "60 9 0.5 N 24 39 0.000 E 10.00m 20m 2000m 20m", + ) + self.equal_loc( + "60 9 1.000 N 24 39 0.000 E 10.00m 20m 2000m 20m", + "60 9 1 N 24 39 0.000 E 10.00m 20m 2000m 20m", + ) # test variable length longtitude - self.equal_loc('60 9 0.000 N 24 39 0.510 E 10.00m 20m 2000m 20m', - '60 9 0.000 N 24 39 0.51 E 10.00m 20m 2000m 20m') - self.equal_loc('60 9 0.000 N 24 39 0.500 E 10.00m 20m 2000m 20m', - '60 9 0.000 N 24 39 0.5 E 10.00m 20m 2000m 20m') - self.equal_loc('60 9 0.000 N 24 39 1.000 E 10.00m 20m 2000m 20m', - '60 9 0.000 N 24 39 1 E 10.00m 20m 2000m 20m') + self.equal_loc( + "60 9 0.000 N 24 39 0.510 E 10.00m 20m 2000m 20m", + "60 9 0.000 N 24 39 0.51 E 10.00m 20m 2000m 20m", + ) + self.equal_loc( + "60 9 0.000 N 24 39 0.500 E 10.00m 20m 2000m 20m", + "60 9 0.000 N 24 39 0.5 E 10.00m 20m 2000m 20m", + ) + self.equal_loc( + "60 9 0.000 N 24 39 1.000 E 10.00m 20m 2000m 20m", + "60 9 0.000 N 24 39 1 E 10.00m 20m 2000m 20m", + ) # test siz, hp, vp defaults - self.equal_loc('60 9 0.510 N 24 39 0.000 E 10.00m', - '60 9 0.51 N 24 39 0.000 E 10.00m 1m 10000m 10m') - self.equal_loc('60 9 0.510 N 24 39 0.000 E 10.00m 2m', - '60 9 0.51 N 24 39 0.000 E 10.00m 2m 10000m 10m') - self.equal_loc('60 9 0.510 N 24 39 0.000 E 10.00m 2m 2000m', - '60 9 0.51 N 24 39 0.000 E 10.00m 2m 2000m 10m') + self.equal_loc( + "60 9 0.510 N 24 39 0.000 E 10.00m", + "60 9 0.51 N 24 39 0.000 E 10.00m 1m 10000m 10m", + ) + self.equal_loc( + "60 9 0.510 N 24 39 0.000 E 10.00m 2m", + "60 9 0.51 N 24 39 0.000 E 10.00m 2m 10000m 10m", + ) + self.equal_loc( + "60 9 0.510 N 24 39 0.000 E 10.00m 2m 2000m", + "60 9 0.51 N 24 39 0.000 E 10.00m 2m 2000m 10m", + ) # test siz, hp, vp optional units - self.equal_loc('60 9 0.510 N 24 39 0.000 E 1m 20m 2000m 20m', - '60 9 0.51 N 24 39 0.000 E 1 20 2000 20') + self.equal_loc( + "60 9 0.510 N 24 39 0.000 E 1m 20m 2000m 20m", + "60 9 0.51 N 24 39 0.000 E 1 20 2000 20", + ) def test_LOC_to_text_SW_hemispheres(self): # As an extra, we test int->float conversion in the constructor loc = LOC(dns.rdataclass.IN, dns.rdatatype.LOC, -60, -24, 1) - text = '60 0 0.000 S 24 0 0.000 W 0.01m' + text = "60 0 0.000 S 24 0 0.000 W 0.01m" self.assertEqual(loc.to_text(), text) def test_zero_size(self): # This is to exercise the 0 path in _exponent_of. - loc = dns.rdata.from_text('in', 'loc', '60 S 24 W 1 0') + loc = dns.rdata.from_text("in", "loc", "60 S 24 W 1 0") self.assertEqual(loc.size, 0.0) def test_bad_LOC_text(self): - bad_locs = ['60 9 a.000 N 24 39 0.000 E 10.00m 20m 2000m 20m', - '60 9 60.000 N 24 39 0.000 E 10.00m 20m 2000m 20m', - '60 9 0.00a N 24 39 0.000 E 10.00m 20m 2000m 20m', - '60 9 0.0001 N 24 39 0.000 E 10.00m 20m 2000m 20m', - '60 9 0.000 Z 24 39 0.000 E 10.00m 20m 2000m 20m', - '91 9 0.000 N 24 39 0.000 E 10.00m 20m 2000m 20m', - '60 60 0.000 N 24 39 0.000 E 10.00m 20m 2000m 20m', - - '60 9 0.000 N 24 39 a.000 E 10.00m 20m 2000m 20m', - '60 9 0.000 N 24 39 60.000 E 10.00m 20m 2000m 20m', - '60 9 0.000 N 24 39 0.00a E 10.00m 20m 2000m 20m', - '60 9 0.000 N 24 39 0.0001 E 10.00m 20m 2000m 20m', - '60 9 0.000 N 24 39 0.000 Z 10.00m 20m 2000m 20m', - '60 9 0.000 N 181 39 0.000 E 10.00m 20m 2000m 20m', - '60 9 0.000 N 24 60 0.000 E 10.00m 20m 2000m 20m', - - '60 9 0.000 N 24 39 0.000 E 10.00m 100000000m 2000m 20m', - '60 9 0.000 N 24 39 0.000 E 10.00m 20m 100000000m 20m', - '60 9 0.000 N 24 39 0.000 E 10.00m 20m 20m 100000000m', - ] + bad_locs = [ + "60 9 a.000 N 24 39 0.000 E 10.00m 20m 2000m 20m", + "60 9 60.000 N 24 39 0.000 E 10.00m 20m 2000m 20m", + "60 9 0.00a N 24 39 0.000 E 10.00m 20m 2000m 20m", + "60 9 0.0001 N 24 39 0.000 E 10.00m 20m 2000m 20m", + "60 9 0.000 Z 24 39 0.000 E 10.00m 20m 2000m 20m", + "91 9 0.000 N 24 39 0.000 E 10.00m 20m 2000m 20m", + "60 60 0.000 N 24 39 0.000 E 10.00m 20m 2000m 20m", + "60 9 0.000 N 24 39 a.000 E 10.00m 20m 2000m 20m", + "60 9 0.000 N 24 39 60.000 E 10.00m 20m 2000m 20m", + "60 9 0.000 N 24 39 0.00a E 10.00m 20m 2000m 20m", + "60 9 0.000 N 24 39 0.0001 E 10.00m 20m 2000m 20m", + "60 9 0.000 N 24 39 0.000 Z 10.00m 20m 2000m 20m", + "60 9 0.000 N 181 39 0.000 E 10.00m 20m 2000m 20m", + "60 9 0.000 N 24 60 0.000 E 10.00m 20m 2000m 20m", + "60 9 0.000 N 24 39 0.000 E 10.00m 100000000m 2000m 20m", + "60 9 0.000 N 24 39 0.000 E 10.00m 20m 100000000m 20m", + "60 9 0.000 N 24 39 0.000 E 10.00m 20m 20m 100000000m", + ] for loc in bad_locs: with self.assertRaises(dns.exception.SyntaxError): dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.LOC, loc) def test_bad_LOC_wire(self): - bad_locs = [(0, 0, 0, 0x934fd901, 0x80000000, 100), - (0, 0, 0, 0x6cb026ff, 0x80000000, 100), - (0, 0, 0, 0x80000000, 0xa69fb201, 100), - (0, 0, 0, 0x80000000, 0x59604dff, 100), - (0xa0, 0, 0, 0x80000000, 0x80000000, 100), - (0x0a, 0, 0, 0x80000000, 0x80000000, 100), - (0, 0xa0, 0, 0x80000000, 0x80000000, 100), - (0, 0x0a, 0, 0x80000000, 0x80000000, 100), - (0, 0, 0xa0, 0x80000000, 0x80000000, 100), - (0, 0, 0x0a, 0x80000000, 0x80000000, 100), - ] + bad_locs = [ + (0, 0, 0, 0x934FD901, 0x80000000, 100), + (0, 0, 0, 0x6CB026FF, 0x80000000, 100), + (0, 0, 0, 0x80000000, 0xA69FB201, 100), + (0, 0, 0, 0x80000000, 0x59604DFF, 100), + (0xA0, 0, 0, 0x80000000, 0x80000000, 100), + (0x0A, 0, 0, 0x80000000, 0x80000000, 100), + (0, 0xA0, 0, 0x80000000, 0x80000000, 100), + (0, 0x0A, 0, 0x80000000, 0x80000000, 100), + (0, 0, 0xA0, 0x80000000, 0x80000000, 100), + (0, 0, 0x0A, 0x80000000, 0x80000000, 100), + ] for t in bad_locs: with self.assertRaises(dns.exception.FormError): - wire = struct.pack('!BBBBIII', 0, t[0], t[1], t[2], - t[3], t[4], t[5]) - dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.LOC, - wire, 0, len(wire)) + wire = struct.pack("!BBBBIII", 0, t[0], t[1], t[2], t[3], t[4], t[5]) + dns.rdata.from_wire( + dns.rdataclass.IN, dns.rdatatype.LOC, wire, 0, len(wire) + ) with self.assertRaises(dns.exception.FormError): - wire = struct.pack('!BBBBIII', 1, 0, 0, 0, 0, 0, 0) - dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.LOC, - wire, 0, len(wire)) + wire = struct.pack("!BBBBIII", 1, 0, 0, 0, 0, 0, 0) + dns.rdata.from_wire( + dns.rdataclass.IN, dns.rdatatype.LOC, wire, 0, len(wire) + ) def equal_wks(self, a, b): rda = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.WKS, a) @@ -387,19 +420,20 @@ class RdataTestCase(unittest.TestCase): self.assertEqual(rda, rdb) def test_misc_good_WKS_text(self): - self.equal_wks('10.0.0.1 tcp ( http )', '10.0.0.1 6 ( 80 )') - self.equal_wks('10.0.0.1 udp ( domain )', '10.0.0.1 17 ( 53 )') + self.equal_wks("10.0.0.1 tcp ( http )", "10.0.0.1 6 ( 80 )") + self.equal_wks("10.0.0.1 udp ( domain )", "10.0.0.1 17 ( 53 )") def test_misc_bad_WKS_text(self): try: - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.WKS, - '10.0.0.1 132 ( domain )') + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.WKS, "10.0.0.1 132 ( domain )" + ) self.assertTrue(False) # should not happen except dns.exception.SyntaxError as e: self.assertIsInstance(e.__cause__, NotImplementedError) def test_GPOS_float_converters(self): - rd = dns.rdata.from_text('in', 'gpos', '49 0 0') + rd = dns.rdata.from_text("in", "gpos", "49 0 0") self.assertEqual(rd.float_latitude, 49.0) self.assertEqual(rd.float_longitude, 0.0) self.assertEqual(rd.float_altitude, 0.0) @@ -415,233 +449,233 @@ class RdataTestCase(unittest.TestCase): self.assertEqual(rd.float_altitude, 0.0) def test_bad_GPOS_text(self): - bad_gpos = ['"-" "116.8652" "250"', - '"+" "116.8652" "250"', - '"" "116.8652" "250"', - '"." "116.8652" "250"', - '".a" "116.8652" "250"', - '"a." "116.8652" "250"', - '"a.a" "116.8652" "250"', - # We don't need to test all the bad permutations again - # but we do want to test that badness is detected - # in the other strings - '"0" "a" "250"', - '"0" "0" "a"', - # finally test bounds - '"90.1" "0" "0"', - '"-90.1" "0" "0"', - '"0" "180.1" "0"', - '"0" "-180.1" "0"', - ] + bad_gpos = [ + '"-" "116.8652" "250"', + '"+" "116.8652" "250"', + '"" "116.8652" "250"', + '"." "116.8652" "250"', + '".a" "116.8652" "250"', + '"a." "116.8652" "250"', + '"a.a" "116.8652" "250"', + # We don't need to test all the bad permutations again + # but we do want to test that badness is detected + # in the other strings + '"0" "a" "250"', + '"0" "0" "a"', + # finally test bounds + '"90.1" "0" "0"', + '"-90.1" "0" "0"', + '"0" "180.1" "0"', + '"0" "-180.1" "0"', + ] for gpos in bad_gpos: with self.assertRaises(dns.exception.SyntaxError): dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.GPOS, gpos) def test_bad_GPOS_wire(self): - bad_gpos = [b'\x01', - b'\x01\x31\x01', - b'\x01\x31\x01\x31\x01', - ] + bad_gpos = [ + b"\x01", + b"\x01\x31\x01", + b"\x01\x31\x01\x31\x01", + ] for wire in bad_gpos: - self.assertRaises(dns.exception.FormError, - lambda: dns.rdata.from_wire(dns.rdataclass.IN, - dns.rdatatype.GPOS, - wire, 0, len(wire))) + self.assertRaises( + dns.exception.FormError, + lambda: dns.rdata.from_wire( + dns.rdataclass.IN, dns.rdatatype.GPOS, wire, 0, len(wire) + ), + ) def test_chaos(self): # avoid red spot on our coverage :) - r1 = dns.rdata.from_text(dns.rdataclass.CH, dns.rdatatype.A, - 'chaos. 12345') + r1 = dns.rdata.from_text(dns.rdataclass.CH, dns.rdatatype.A, "chaos. 12345") w = r1.to_wire() - r2 = dns.rdata.from_wire(dns.rdataclass.CH, dns.rdatatype.A, w, 0, - len(w)) + r2 = dns.rdata.from_wire(dns.rdataclass.CH, dns.rdatatype.A, w, 0, len(w)) self.assertEqual(r1, r2) - self.assertEqual(r1.domain, dns.name.from_text('chaos')) + self.assertEqual(r1.domain, dns.name.from_text("chaos")) # the address input is octal self.assertEqual(r1.address, 0o12345) - self.assertEqual(r1.to_text(), 'chaos. 12345') + self.assertEqual(r1.to_text(), "chaos. 12345") def test_opt_repr(self): opt = OPT(4096, dns.rdatatype.OPT, ()) - self.assertEqual(repr(opt), '<DNS CLASS4096 OPT rdata: >') + self.assertEqual(repr(opt), "<DNS CLASS4096 OPT rdata: >") def test_opt_short_lengths(self): with self.assertRaises(dns.exception.FormError): - parser = dns.wire.Parser(bytes.fromhex('f00102')) + parser = dns.wire.Parser(bytes.fromhex("f00102")) OPT.from_wire_parser(4096, dns.rdatatype.OPT, parser) with self.assertRaises(dns.exception.FormError): - parser = dns.wire.Parser(bytes.fromhex('f00100030000')) + parser = dns.wire.Parser(bytes.fromhex("f00100030000")) OPT.from_wire_parser(4096, dns.rdatatype.OPT, parser) def test_from_wire_parser(self): - wire = bytes.fromhex('01020304') - rdata = dns.rdata.from_wire('in', 'a', wire, 0, 4) - self.assertEqual(rdata, dns.rdata.from_text('in', 'a', '1.2.3.4')) + wire = bytes.fromhex("01020304") + rdata = dns.rdata.from_wire("in", "a", wire, 0, 4) + self.assertEqual(rdata, dns.rdata.from_text("in", "a", "1.2.3.4")) def test_unpickle(self): - expected_mx = dns.rdata.from_text('in', 'mx', '10 mx.example.') - with open(here('mx-2-0.pickle'), 'rb') as f: + expected_mx = dns.rdata.from_text("in", "mx", "10 mx.example.") + with open(here("mx-2-0.pickle"), "rb") as f: mx = pickle.load(f) self.assertEqual(mx, expected_mx) self.assertIsNone(mx.rdcomment) def test_escaped_newline_in_quoted_string(self): - rd = dns.rdata.from_text('in', 'txt', '"foo\\\nbar"') - self.assertEqual(rd.strings, (b'foo\nbar',)) + rd = dns.rdata.from_text("in", "txt", '"foo\\\nbar"') + self.assertEqual(rd.strings, (b"foo\nbar",)) self.assertEqual(rd.to_text(), '"foo\\010bar"') def test_escaped_newline_in_nonquoted_string(self): with self.assertRaises(dns.exception.UnexpectedEnd): - dns.rdata.from_text('in', 'txt', 'foo\\\nbar') + dns.rdata.from_text("in", "txt", "foo\\\nbar") def test_wordbreak(self): - text = b'abcdefgh' - self.assertEqual(dns.rdata._wordbreak(text, 4), 'abcd efgh') - self.assertEqual(dns.rdata._wordbreak(text, 0), 'abcdefgh') + text = b"abcdefgh" + self.assertEqual(dns.rdata._wordbreak(text, 4), "abcd efgh") + self.assertEqual(dns.rdata._wordbreak(text, 0), "abcdefgh") def test_escapify(self): - self.assertEqual(dns.rdata._escapify('abc'), 'abc') - self.assertEqual(dns.rdata._escapify(b'abc'), 'abc') - self.assertEqual(dns.rdata._escapify(bytearray(b'abc')), 'abc') + self.assertEqual(dns.rdata._escapify("abc"), "abc") + self.assertEqual(dns.rdata._escapify(b"abc"), "abc") + self.assertEqual(dns.rdata._escapify(bytearray(b"abc")), "abc") self.assertEqual(dns.rdata._escapify(b'ab"c'), 'ab\\"c') - self.assertEqual(dns.rdata._escapify(b'ab\\c'), 'ab\\\\c') - self.assertEqual(dns.rdata._escapify(b'ab\x01c'), 'ab\\001c') + self.assertEqual(dns.rdata._escapify(b"ab\\c"), "ab\\\\c") + self.assertEqual(dns.rdata._escapify(b"ab\x01c"), "ab\\001c") def test_truncate_bitmap(self): - self.assertEqual(dns.rdata._truncate_bitmap(b'\x00\x01\x00\x00'), - b'\x00\x01') - self.assertEqual(dns.rdata._truncate_bitmap(b'\x00\x01\x00\x01'), - b'\x00\x01\x00\x01') - self.assertEqual(dns.rdata._truncate_bitmap(b'\x00\x00\x00\x00'), - b'\x00') + self.assertEqual(dns.rdata._truncate_bitmap(b"\x00\x01\x00\x00"), b"\x00\x01") + self.assertEqual( + dns.rdata._truncate_bitmap(b"\x00\x01\x00\x01"), b"\x00\x01\x00\x01" + ) + self.assertEqual(dns.rdata._truncate_bitmap(b"\x00\x00\x00\x00"), b"\x00") def test_covers_and_extended_rdatatype(self): - rd = dns.rdata.from_text('in', 'a', '10.0.0.1') + rd = dns.rdata.from_text("in", "a", "10.0.0.1") self.assertEqual(rd.covers(), dns.rdatatype.NONE) self.assertEqual(rd.extended_rdatatype(), 0x00000001) - rd = dns.rdata.from_text('in', 'rrsig', - 'NSEC 1 3 3600 ' + - '20200101000000 20030101000000 ' + - '2143 foo Ym9ndXM=') + rd = dns.rdata.from_text( + "in", + "rrsig", + "NSEC 1 3 3600 " + "20200101000000 20030101000000 " + "2143 foo Ym9ndXM=", + ) self.assertEqual(rd.covers(), dns.rdatatype.NSEC) - self.assertEqual(rd.extended_rdatatype(), 0x002f002e) + self.assertEqual(rd.extended_rdatatype(), 0x002F002E) def test_uncomparable(self): - rd = dns.rdata.from_text('in', 'a', '10.0.0.1') - self.assertFalse(rd == 'a') - self.assertTrue(rd != 'a') + rd = dns.rdata.from_text("in", "a", "10.0.0.1") + self.assertFalse(rd == "a") + self.assertTrue(rd != "a") def test_bad_generic(self): # does not start with \# with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'type45678', '# 7 000a03666f6f00') + dns.rdata.from_text("in", "type45678", "# 7 000a03666f6f00") # wrong length with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'type45678', '\\# 6 000a03666f6f00') + dns.rdata.from_text("in", "type45678", "\\# 6 000a03666f6f00") def test_empty_generic(self): - dns.rdata.from_text('in', 'type45678', r'\# 0') + dns.rdata.from_text("in", "type45678", r"\# 0") def test_covered_repr(self): - text = 'NSEC 1 3 3600 20190101000000 20030101000000 ' + \ - '2143 foo Ym9ndXM=' - rd = dns.rdata.from_text('in', 'rrsig', text) - self.assertEqual(repr(rd), '<DNS IN RRSIG(NSEC) rdata: ' + text + '>') + text = "NSEC 1 3 3600 20190101000000 20030101000000 " + "2143 foo Ym9ndXM=" + rd = dns.rdata.from_text("in", "rrsig", text) + self.assertEqual(repr(rd), "<DNS IN RRSIG(NSEC) rdata: " + text + ">") def test_bad_registration_implementing_known_type_with_wrong_name(self): # Try to register an implementation at the MG codepoint that isn't # called "MG" with self.assertRaises(dns.rdata.RdatatypeExists): - dns.rdata.register_type(None, dns.rdatatype.MG, 'NOTMG') + dns.rdata.register_type(None, dns.rdatatype.MG, "NOTMG") def test_registration_implementing_known_type_with_right_name(self): # Try to register an implementation at the MD codepoint - dns.rdata.register_type(tests.md_module, dns.rdatatype.MD, 'MD') - rd = dns.rdata.from_text('in', 'md', 'foo.') - self.assertEqual(rd.target, dns.name.from_text('foo.')) + dns.rdata.register_type(tests.md_module, dns.rdatatype.MD, "MD") + rd = dns.rdata.from_text("in", "md", "foo.") + self.assertEqual(rd.target, dns.name.from_text("foo.")) def test_CERT_with_string_type(self): - rd = dns.rdata.from_text('in', 'cert', 'SPKI 1 PRIVATEOID Ym9ndXM=') - self.assertEqual(rd.to_text(), 'SPKI 1 PRIVATEOID Ym9ndXM=') + rd = dns.rdata.from_text("in", "cert", "SPKI 1 PRIVATEOID Ym9ndXM=") + self.assertEqual(rd.to_text(), "SPKI 1 PRIVATEOID Ym9ndXM=") def test_CERT_algorithm(self): - rd = dns.rdata.from_text('in', 'cert', 'SPKI 1 0 Ym9ndXM=') + rd = dns.rdata.from_text("in", "cert", "SPKI 1 0 Ym9ndXM=") self.assertEqual(rd.algorithm, 0) with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'cert', 'SPKI 1 -1 Ym9ndXM=') + dns.rdata.from_text("in", "cert", "SPKI 1 -1 Ym9ndXM=") with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'cert', 'SPKI 1 256 Ym9ndXM=') + dns.rdata.from_text("in", "cert", "SPKI 1 256 Ym9ndXM=") with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'cert', 'SPKI 1 BOGUS Ym9ndXM=') + dns.rdata.from_text("in", "cert", "SPKI 1 BOGUS Ym9ndXM=") def test_bad_URI_text(self): # empty target with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'uri', '10 1 ""') + dns.rdata.from_text("in", "uri", '10 1 ""') # no target with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'uri', '10 1') + dns.rdata.from_text("in", "uri", "10 1") def test_bad_URI_wire(self): - wire = bytes.fromhex('000a0001') + wire = bytes.fromhex("000a0001") with self.assertRaises(dns.exception.FormError): - dns.rdata.from_wire('in', 'uri', wire, 0, 4) + dns.rdata.from_wire("in", "uri", wire, 0, 4) def test_bad_NSAP_text(self): # does not start with 0x with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'nsap', '0y4700') + dns.rdata.from_text("in", "nsap", "0y4700") # odd hex string length with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'nsap', '0x470') + dns.rdata.from_text("in", "nsap", "0x470") def test_bad_CAA_text(self): # tag too long with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'caa', - '0 ' + 'a' * 256 + ' "ca.example.net"') + dns.rdata.from_text("in", "caa", "0 " + "a" * 256 + ' "ca.example.net"') # tag not alphanumeric with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'caa', - '0 a-b "ca.example.net"') + dns.rdata.from_text("in", "caa", '0 a-b "ca.example.net"') def test_bad_HIP_text(self): # hit too long with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'hip', - '2 ' + - '00' * 256 + - ' Ym9ndXM=') + dns.rdata.from_text("in", "hip", "2 " + "00" * 256 + " Ym9ndXM=") def test_bad_sigtime(self): try: - dns.rdata.from_text('in', 'rrsig', - 'NSEC 1 3 3600 ' + - '202001010000000 20030101000000 ' + - '2143 foo Ym9ndXM=') + dns.rdata.from_text( + "in", + "rrsig", + "NSEC 1 3 3600 " + + "202001010000000 20030101000000 " + + "2143 foo Ym9ndXM=", + ) self.assertTrue(False) # should not happen except dns.exception.SyntaxError as e: - self.assertIsInstance(e.__cause__, - dns.rdtypes.ANY.RRSIG.BadSigTime) + self.assertIsInstance(e.__cause__, dns.rdtypes.ANY.RRSIG.BadSigTime) try: - dns.rdata.from_text('in', 'rrsig', - 'NSEC 1 3 3600 ' + - '20200101000000 2003010100000 ' + - '2143 foo Ym9ndXM=') + dns.rdata.from_text( + "in", + "rrsig", + "NSEC 1 3 3600 " + + "20200101000000 2003010100000 " + + "2143 foo Ym9ndXM=", + ) self.assertTrue(False) # should not happen except dns.exception.SyntaxError as e: - self.assertIsInstance(e.__cause__, - dns.rdtypes.ANY.RRSIG.BadSigTime) + self.assertIsInstance(e.__cause__, dns.rdtypes.ANY.RRSIG.BadSigTime) def test_empty_TXT(self): # hit too long with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'txt', '') + dns.rdata.from_text("in", "txt", "") def test_too_long_TXT(self): # hit too long with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'txt', 'a' * 256) + dns.rdata.from_text("in", "txt", "a" * 256) def equal_smimea(self, a, b): a = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SMIMEA, a) @@ -649,63 +683,65 @@ class RdataTestCase(unittest.TestCase): self.assertEqual(a, b) def test_good_SMIMEA(self): - self.equal_smimea('3 0 1 aabbccddeeff', '3 0 01 AABBCCDDEEFF') + self.equal_smimea("3 0 1 aabbccddeeff", "3 0 01 AABBCCDDEEFF") def test_bad_SMIMEA(self): with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SMIMEA, '1 1 1 aGVsbG8gd29ybGQh') + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SMIMEA, "1 1 1 aGVsbG8gd29ybGQh" + ) def test_bad_APLItem_address_length(self): with self.assertRaises(ValueError): # 9999 is used in as an "unknown" address family. In the unlikely # event it is ever defined, we should switch the test to another # value. - dns.rdtypes.IN.APL.APLItem(9999, False, b'0xff' * 128, 255) + dns.rdtypes.IN.APL.APLItem(9999, False, b"0xff" * 128, 255) def test_DNSKEY_chunking(self): inputs = ( # each with chunking as given by dig, unusual chunking, and no chunking # example 1 ( - '257 3 13 aCoEWYBBVsP9Fek2oC8yqU8ocKmnS1iDSFZNORnQuHKtJ9Wpyz+kNryq uB78Pyk/NTEoai5bxoipVQQXzHlzyg==', - '257 3 13 aCoEWYBBVsP9Fek2oC8yqU8ocK mnS1iDSFZNORnQuHKtJ9Wpyz+kNryquB78Pyk/ NTEoai5bxoipVQQXzHlzyg==', - '257 3 13 aCoEWYBBVsP9Fek2oC8yqU8ocKmnS1iDSFZNORnQuHKtJ9Wpyz+kNryquB78Pyk/NTEoai5bxoipVQQXzHlzyg==', + "257 3 13 aCoEWYBBVsP9Fek2oC8yqU8ocKmnS1iDSFZNORnQuHKtJ9Wpyz+kNryq uB78Pyk/NTEoai5bxoipVQQXzHlzyg==", + "257 3 13 aCoEWYBBVsP9Fek2oC8yqU8ocK mnS1iDSFZNORnQuHKtJ9Wpyz+kNryquB78Pyk/ NTEoai5bxoipVQQXzHlzyg==", + "257 3 13 aCoEWYBBVsP9Fek2oC8yqU8ocKmnS1iDSFZNORnQuHKtJ9Wpyz+kNryquB78Pyk/NTEoai5bxoipVQQXzHlzyg==", ), # example 2 ( - '257 3 8 AwEAAcw5QLr0IjC0wKbGoBPQv4qmeqHy9mvL5qGQTuaG5TSrNqEAR6b/ qvxDx6my4JmEmjUPA1JeEI9YfTUieMr2UZflu7aIbZFLw0vqiYrywCGr CHXLalOrEOmrvAxLvq4vHtuTlH7JIszzYBSes8g1vle6KG7xXiP3U5Ll 96Qiu6bZ31rlMQSPB20xbqJJh6psNSrQs41QvdcXAej+K2Hl1Wd8kPri ec4AgiBEh8sk5Pp8W9ROLQ7PcbqqttFaW2m7N/Wy4qcFU13roWKDEAst bxH5CHPoBfZSbIwK4KM6BK/uDHpSPIbiOvOCW+lvu9TAiZPc0oysY6as lO7jXv16Gws=', - '257 3 8 AwEAAcw5QLr0IjC0wKbGoBPQv4qmeq Hy9mvL5qGQTuaG5TSrNqEA R6b/qvxDx6my4JmEmjUPA1JeEI9Y fTUieMr2UZflu7aIbZFLw0vqiYrywCGrC HXLalOrEOmrvAxLvq4vHtuTlH7JIszzYBSes8g1vle6KG7 xXiP3U5Ll 96Qiu6bZ31rlMQSPB20xbqJJh6psNSrQs41QvdcXAej+K2Hl1Wd8kPriec4AgiBEh8sk5Pp8W9ROLQ7PcbqqttFaW2m7N/Wy4qcFU13roWKDEAst bxH5CHPoBfZSbIwK4KM6BK/uDHpSPIbiOvOCW+lvu9TAiZPc0oysY6as lO7jXv16Gws=', - '257 3 8 AwEAAcw5QLr0IjC0wKbGoBPQv4qmeqHy9mvL5qGQTuaG5TSrNqEAR6b/qvxDx6my4JmEmjUPA1JeEI9YfTUieMr2UZflu7aIbZFLw0vqiYrywCGrCHXLalOrEOmrvAxLvq4vHtuTlH7JIszzYBSes8g1vle6KG7xXiP3U5Ll96Qiu6bZ31rlMQSPB20xbqJJh6psNSrQs41QvdcXAej+K2Hl1Wd8kPriec4AgiBEh8sk5Pp8W9ROLQ7PcbqqttFaW2m7N/Wy4qcFU13roWKDEAstbxH5CHPoBfZSbIwK4KM6BK/uDHpSPIbiOvOCW+lvu9TAiZPc0oysY6aslO7jXv16Gws=', + "257 3 8 AwEAAcw5QLr0IjC0wKbGoBPQv4qmeqHy9mvL5qGQTuaG5TSrNqEAR6b/ qvxDx6my4JmEmjUPA1JeEI9YfTUieMr2UZflu7aIbZFLw0vqiYrywCGr CHXLalOrEOmrvAxLvq4vHtuTlH7JIszzYBSes8g1vle6KG7xXiP3U5Ll 96Qiu6bZ31rlMQSPB20xbqJJh6psNSrQs41QvdcXAej+K2Hl1Wd8kPri ec4AgiBEh8sk5Pp8W9ROLQ7PcbqqttFaW2m7N/Wy4qcFU13roWKDEAst bxH5CHPoBfZSbIwK4KM6BK/uDHpSPIbiOvOCW+lvu9TAiZPc0oysY6as lO7jXv16Gws=", + "257 3 8 AwEAAcw5QLr0IjC0wKbGoBPQv4qmeq Hy9mvL5qGQTuaG5TSrNqEA R6b/qvxDx6my4JmEmjUPA1JeEI9Y fTUieMr2UZflu7aIbZFLw0vqiYrywCGrC HXLalOrEOmrvAxLvq4vHtuTlH7JIszzYBSes8g1vle6KG7 xXiP3U5Ll 96Qiu6bZ31rlMQSPB20xbqJJh6psNSrQs41QvdcXAej+K2Hl1Wd8kPriec4AgiBEh8sk5Pp8W9ROLQ7PcbqqttFaW2m7N/Wy4qcFU13roWKDEAst bxH5CHPoBfZSbIwK4KM6BK/uDHpSPIbiOvOCW+lvu9TAiZPc0oysY6as lO7jXv16Gws=", + "257 3 8 AwEAAcw5QLr0IjC0wKbGoBPQv4qmeqHy9mvL5qGQTuaG5TSrNqEAR6b/qvxDx6my4JmEmjUPA1JeEI9YfTUieMr2UZflu7aIbZFLw0vqiYrywCGrCHXLalOrEOmrvAxLvq4vHtuTlH7JIszzYBSes8g1vle6KG7xXiP3U5Ll96Qiu6bZ31rlMQSPB20xbqJJh6psNSrQs41QvdcXAej+K2Hl1Wd8kPriec4AgiBEh8sk5Pp8W9ROLQ7PcbqqttFaW2m7N/Wy4qcFU13roWKDEAstbxH5CHPoBfZSbIwK4KM6BK/uDHpSPIbiOvOCW+lvu9TAiZPc0oysY6aslO7jXv16Gws=", ), # example 3 ( - '256 3 8 AwEAAday3UX323uVzQqtOMQ7EHQYfD5Ofv4akjQGN2zY5AgB/2jmdR/+ 1PvXFqzKCAGJv4wjABEBNWLLFm7ew1hHMDZEKVL17aml0EBKI6Dsz6Mx t6n7ScvLtHaFRKaxT4i2JxiuVhKdQR9XGMiWAPQKrRM5SLG0P+2F+TLK l3D0L/cD', - '256 3 8 AwEAAday3UX323uVzQqtOMQ7EHQYfD5Ofv4akjQGN2zY5 AgB/2jmdR/+1PvXFqzKCAGJv4wjABEBNWLLFm7ew1hHMDZEKVL17aml0EBKI6Dsz6Mxt6n7ScvLtHaFRKaxT4i2JxiuVhKdQR9XGMiWAPQKrRM5SLG0P+2F+ TLKl3D0L/cD', - '256 3 8 AwEAAday3UX323uVzQqtOMQ7EHQYfD5Ofv4akjQGN2zY5AgB/2jmdR/+1PvXFqzKCAGJv4wjABEBNWLLFm7ew1hHMDZEKVL17aml0EBKI6Dsz6Mxt6n7ScvLtHaFRKaxT4i2JxiuVhKdQR9XGMiWAPQKrRM5SLG0P+2F+TLKl3D0L/cD', + "256 3 8 AwEAAday3UX323uVzQqtOMQ7EHQYfD5Ofv4akjQGN2zY5AgB/2jmdR/+ 1PvXFqzKCAGJv4wjABEBNWLLFm7ew1hHMDZEKVL17aml0EBKI6Dsz6Mx t6n7ScvLtHaFRKaxT4i2JxiuVhKdQR9XGMiWAPQKrRM5SLG0P+2F+TLK l3D0L/cD", + "256 3 8 AwEAAday3UX323uVzQqtOMQ7EHQYfD5Ofv4akjQGN2zY5 AgB/2jmdR/+1PvXFqzKCAGJv4wjABEBNWLLFm7ew1hHMDZEKVL17aml0EBKI6Dsz6Mxt6n7ScvLtHaFRKaxT4i2JxiuVhKdQR9XGMiWAPQKrRM5SLG0P+2F+ TLKl3D0L/cD", + "256 3 8 AwEAAday3UX323uVzQqtOMQ7EHQYfD5Ofv4akjQGN2zY5AgB/2jmdR/+1PvXFqzKCAGJv4wjABEBNWLLFm7ew1hHMDZEKVL17aml0EBKI6Dsz6Mxt6n7ScvLtHaFRKaxT4i2JxiuVhKdQR9XGMiWAPQKrRM5SLG0P+2F+TLKl3D0L/cD", ), ) output_map = { 32: ( - '257 3 13 aCoEWYBBVsP9Fek2oC8yqU8ocKmnS1iD SFZNORnQuHKtJ9Wpyz+kNryquB78Pyk/ NTEoai5bxoipVQQXzHlzyg==', - '257 3 8 AwEAAcw5QLr0IjC0wKbGoBPQv4qmeqHy 9mvL5qGQTuaG5TSrNqEAR6b/qvxDx6my 4JmEmjUPA1JeEI9YfTUieMr2UZflu7aI bZFLw0vqiYrywCGrCHXLalOrEOmrvAxL vq4vHtuTlH7JIszzYBSes8g1vle6KG7x XiP3U5Ll96Qiu6bZ31rlMQSPB20xbqJJ h6psNSrQs41QvdcXAej+K2Hl1Wd8kPri ec4AgiBEh8sk5Pp8W9ROLQ7PcbqqttFa W2m7N/Wy4qcFU13roWKDEAstbxH5CHPo BfZSbIwK4KM6BK/uDHpSPIbiOvOCW+lv u9TAiZPc0oysY6aslO7jXv16Gws=', - '256 3 8 AwEAAday3UX323uVzQqtOMQ7EHQYfD5O fv4akjQGN2zY5AgB/2jmdR/+1PvXFqzK CAGJv4wjABEBNWLLFm7ew1hHMDZEKVL1 7aml0EBKI6Dsz6Mxt6n7ScvLtHaFRKax T4i2JxiuVhKdQR9XGMiWAPQKrRM5SLG0 P+2F+TLKl3D0L/cD', + "257 3 13 aCoEWYBBVsP9Fek2oC8yqU8ocKmnS1iD SFZNORnQuHKtJ9Wpyz+kNryquB78Pyk/ NTEoai5bxoipVQQXzHlzyg==", + "257 3 8 AwEAAcw5QLr0IjC0wKbGoBPQv4qmeqHy 9mvL5qGQTuaG5TSrNqEAR6b/qvxDx6my 4JmEmjUPA1JeEI9YfTUieMr2UZflu7aI bZFLw0vqiYrywCGrCHXLalOrEOmrvAxL vq4vHtuTlH7JIszzYBSes8g1vle6KG7x XiP3U5Ll96Qiu6bZ31rlMQSPB20xbqJJ h6psNSrQs41QvdcXAej+K2Hl1Wd8kPri ec4AgiBEh8sk5Pp8W9ROLQ7PcbqqttFa W2m7N/Wy4qcFU13roWKDEAstbxH5CHPo BfZSbIwK4KM6BK/uDHpSPIbiOvOCW+lv u9TAiZPc0oysY6aslO7jXv16Gws=", + "256 3 8 AwEAAday3UX323uVzQqtOMQ7EHQYfD5O fv4akjQGN2zY5AgB/2jmdR/+1PvXFqzK CAGJv4wjABEBNWLLFm7ew1hHMDZEKVL1 7aml0EBKI6Dsz6Mxt6n7ScvLtHaFRKax T4i2JxiuVhKdQR9XGMiWAPQKrRM5SLG0 P+2F+TLKl3D0L/cD", ), 56: (t[0] for t in inputs), - 0: (t[0][:12] + t[0][12:].replace(' ', '') for t in inputs) + 0: (t[0][:12] + t[0][12:].replace(" ", "") for t in inputs), } for chunksize, outputs in output_map.items(): for input, output in zip(inputs, outputs): for input_variation in input: - rr = dns.rdata.from_text('IN', 'DNSKEY', input_variation) + rr = dns.rdata.from_text("IN", "DNSKEY", input_variation) new_text = rr.to_text(chunksize=chunksize) self.assertEqual(output, new_text) - + def test_relative_vs_absolute_compare_unstrict(self): try: saved = dns.rdata._allow_relative_comparisons dns.rdata._allow_relative_comparisons = True - r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, 'www.') - r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, 'www') + r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "www.") + r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "www") self.assertFalse(r1 == r2) self.assertTrue(r1 != r2) self.assertFalse(r1 < r2) @@ -723,18 +759,23 @@ class RdataTestCase(unittest.TestCase): try: saved = dns.rdata._allow_relative_comparisons dns.rdata._allow_relative_comparisons = False - r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, 'www.') - r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, 'www') + r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "www.") + r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "www") self.assertFalse(r1 == r2) self.assertTrue(r1 != r2) + def bad1(): r1 < r2 + def bad2(): r1 <= r2 + def bad3(): r1 > r2 + def bad4(): r1 >= r2 + self.assertRaises(dns.rdata.NoRelativeRdataOrdering, bad1) self.assertRaises(dns.rdata.NoRelativeRdataOrdering, bad2) self.assertRaises(dns.rdata.NoRelativeRdataOrdering, bad3) @@ -743,8 +784,8 @@ class RdataTestCase(unittest.TestCase): dns.rdata._allow_relative_comparisons = saved def test_absolute_vs_absolute_compare(self): - r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, 'www.') - r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, 'xxx.') + r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "www.") + r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "xxx.") self.assertFalse(r1 == r2) self.assertTrue(r1 != r2) self.assertTrue(r1 < r2) @@ -756,8 +797,8 @@ class RdataTestCase(unittest.TestCase): try: saved = dns.rdata._allow_relative_comparisons dns.rdata._allow_relative_comparisons = True - r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, 'www') - r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, 'xxx') + r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "www") + r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "xxx") self.assertFalse(r1 == r2) self.assertTrue(r1 != r2) self.assertTrue(r1 < r2) @@ -771,18 +812,23 @@ class RdataTestCase(unittest.TestCase): try: saved = dns.rdata._allow_relative_comparisons dns.rdata._allow_relative_comparisons = False - r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, 'www') - r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, 'xxx') + r1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "www") + r2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "xxx") self.assertFalse(r1 == r2) self.assertTrue(r1 != r2) + def bad1(): r1 < r2 + def bad2(): r1 <= r2 + def bad3(): r1 > r2 + def bad4(): r1 >= r2 + self.assertRaises(dns.rdata.NoRelativeRdataOrdering, bad1) self.assertRaises(dns.rdata.NoRelativeRdataOrdering, bad2) self.assertRaises(dns.rdata.NoRelativeRdataOrdering, bad3) @@ -790,15 +836,15 @@ class RdataTestCase(unittest.TestCase): finally: dns.rdata._allow_relative_comparisons = saved -class UtilTestCase(unittest.TestCase): +class UtilTestCase(unittest.TestCase): def test_Gateway_bad_type0(self): with self.assertRaises(SyntaxError): - dns.rdtypes.util.Gateway(0, 'bad.') + dns.rdtypes.util.Gateway(0, "bad.") def test_Gateway_bad_type3(self): with self.assertRaises(SyntaxError): - dns.rdtypes.util.Gateway(3, 'bad.') + dns.rdtypes.util.Gateway(3, "bad.") def test_Gateway_type4(self): with self.assertRaises(SyntaxError): @@ -808,7 +854,7 @@ class UtilTestCase(unittest.TestCase): def test_Bitmap(self): b = dns.rdtypes.util.Bitmap - tok = dns.tokenizer.Tokenizer('A MX') + tok = dns.tokenizer.Tokenizer("A MX") windows = b.from_text(tok).windows ba = bytearray() ba.append(0x40) # bit 1, for A @@ -817,7 +863,7 @@ class UtilTestCase(unittest.TestCase): def test_Bitmap_with_duplicate_types(self): b = dns.rdtypes.util.Bitmap - tok = dns.tokenizer.Tokenizer('A MX A A MX') + tok = dns.tokenizer.Tokenizer("A MX A A MX") windows = b.from_text(tok).windows ba = bytearray() ba.append(0x40) # bit 1, for A @@ -826,7 +872,7 @@ class UtilTestCase(unittest.TestCase): def test_Bitmap_with_out_of_order_types(self): b = dns.rdtypes.util.Bitmap - tok = dns.tokenizer.Tokenizer('MX A') + tok = dns.tokenizer.Tokenizer("MX A") windows = b.from_text(tok).windows ba = bytearray() ba.append(0x40) # bit 1, for A @@ -835,7 +881,7 @@ class UtilTestCase(unittest.TestCase): def test_Bitmap_zero_padding_works(self): b = dns.rdtypes.util.Bitmap - tok = dns.tokenizer.Tokenizer('SRV') + tok = dns.tokenizer.Tokenizer("SRV") windows = b.from_text(tok).windows ba = bytearray() ba.append(0) @@ -848,49 +894,48 @@ class UtilTestCase(unittest.TestCase): def test_Bitmap_has_type_0_set(self): b = dns.rdtypes.util.Bitmap with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('NONE A MX') + tok = dns.tokenizer.Tokenizer("NONE A MX") b.from_text(tok) def test_Bitmap_empty_window_not_written(self): b = dns.rdtypes.util.Bitmap - tok = dns.tokenizer.Tokenizer('URI CAA') # types 256 and 257 + tok = dns.tokenizer.Tokenizer("URI CAA") # types 256 and 257 windows = b.from_text(tok).windows ba = bytearray() - ba.append(0xc0) # bits 0 and 1 in window 1 + ba.append(0xC0) # bits 0 and 1 in window 1 self.assertEqual(windows, [(1, bytes(ba))]) def test_Bitmap_ok_parse(self): - parser = dns.wire.Parser(b'\x00\x01\x40') + parser = dns.wire.Parser(b"\x00\x01\x40") b = dns.rdtypes.util.Bitmap([]) windows = b.from_wire_parser(parser).windows - self.assertEqual(windows, [(0, b'@')]) + self.assertEqual(windows, [(0, b"@")]) def test_Bitmap_0_length_window_parse(self): - parser = dns.wire.Parser(b'\x00\x00') + parser = dns.wire.Parser(b"\x00\x00") with self.assertRaises(ValueError): b = dns.rdtypes.util.Bitmap([]) b.from_wire_parser(parser) def test_Bitmap_too_long_parse(self): - parser = dns.wire.Parser(b'\x00\x21' + b'\x01' * 33) + parser = dns.wire.Parser(b"\x00\x21" + b"\x01" * 33) with self.assertRaises(ValueError): b = dns.rdtypes.util.Bitmap([]) b.from_wire_parser(parser) def test_compressed_in_generic_is_bad(self): with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, - r'\# 4 000aC000') + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, r"\# 4 000aC000") def test_rdataset_ttl_conversion(self): - rds1 = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1') + rds1 = dns.rdataset.from_text("in", "a", 300, "10.0.0.1") self.assertEqual(rds1.ttl, 300) - rds2 = dns.rdataset.from_text('in', 'a', '5m', '10.0.0.1') + rds2 = dns.rdataset.from_text("in", "a", "5m", "10.0.0.1") self.assertEqual(rds2.ttl, 300) with self.assertRaises(ValueError): - dns.rdataset.from_text('in', 'a', 1.6, '10.0.0.1') + dns.rdataset.from_text("in", "a", 1.6, "10.0.0.1") with self.assertRaises(dns.ttl.BadTTL): - dns.rdataset.from_text('in', 'a', '10.0.0.1', '10.0.0.2') + dns.rdataset.from_text("in", "a", "10.0.0.1", "10.0.0.2") Rdata = dns.rdata.Rdata @@ -898,16 +943,16 @@ Rdata = dns.rdata.Rdata class RdataConvertersTestCase(unittest.TestCase): def test_as_name(self): - n = dns.name.from_text('hi') + n = dns.name.from_text("hi") self.assertEqual(Rdata._as_name(n), n) - self.assertEqual(Rdata._as_name('hi'), n) + self.assertEqual(Rdata._as_name("hi"), n) with self.assertRaises(ValueError): Rdata._as_name(100) def test_as_uint8(self): self.assertEqual(Rdata._as_uint8(0), 0) with self.assertRaises(ValueError): - Rdata._as_uint8('hi') + Rdata._as_uint8("hi") with self.assertRaises(ValueError): Rdata._as_uint8(-1) with self.assertRaises(ValueError): @@ -916,7 +961,7 @@ class RdataConvertersTestCase(unittest.TestCase): def test_as_uint16(self): self.assertEqual(Rdata._as_uint16(0), 0) with self.assertRaises(ValueError): - Rdata._as_uint16('hi') + Rdata._as_uint16("hi") with self.assertRaises(ValueError): Rdata._as_uint16(-1) with self.assertRaises(ValueError): @@ -925,25 +970,25 @@ class RdataConvertersTestCase(unittest.TestCase): def test_as_uint32(self): self.assertEqual(Rdata._as_uint32(0), 0) with self.assertRaises(ValueError): - Rdata._as_uint32('hi') + Rdata._as_uint32("hi") with self.assertRaises(ValueError): Rdata._as_uint32(-1) with self.assertRaises(ValueError): - Rdata._as_uint32(2 ** 32) + Rdata._as_uint32(2**32) def test_as_uint48(self): self.assertEqual(Rdata._as_uint48(0), 0) with self.assertRaises(ValueError): - Rdata._as_uint48('hi') + Rdata._as_uint48("hi") with self.assertRaises(ValueError): Rdata._as_uint48(-1) with self.assertRaises(ValueError): - Rdata._as_uint48(2 ** 48) + Rdata._as_uint48(2**48) def test_as_int(self): self.assertEqual(Rdata._as_int(0, 0, 10), 0) with self.assertRaises(ValueError): - Rdata._as_int('hi', 0, 10) + Rdata._as_int("hi", 0, 10) with self.assertRaises(ValueError): Rdata._as_int(-1, 0, 10) with self.assertRaises(ValueError): @@ -953,18 +998,19 @@ class RdataConvertersTestCase(unittest.TestCase): self.assertEqual(Rdata._as_bool(True), True) self.assertEqual(Rdata._as_bool(False), False) with self.assertRaises(ValueError): - Rdata._as_bool('hi') + Rdata._as_bool("hi") def test_as_ttl(self): self.assertEqual(Rdata._as_ttl(300), 300) - self.assertEqual(Rdata._as_ttl('5m'), 300) + self.assertEqual(Rdata._as_ttl("5m"), 300) self.assertEqual(Rdata._as_ttl(dns.ttl.MAX_TTL), dns.ttl.MAX_TTL) with self.assertRaises(dns.ttl.BadTTL): - Rdata._as_ttl('hi') + Rdata._as_ttl("hi") with self.assertRaises(ValueError): Rdata._as_ttl(1.9) with self.assertRaises(ValueError): Rdata._as_ttl(dns.ttl.MAX_TTL + 1) -if __name__ == '__main__': + +if __name__ == "__main__": unittest.main() diff --git a/tests/test_rdataset.py b/tests/test_rdataset.py index 69ec6de..4c602f8 100644 --- a/tests/test_rdataset.py +++ b/tests/test_rdataset.py @@ -9,123 +9,119 @@ import dns.rdataclass import dns.rdataset import dns.rdatatype -class RdatasetTestCase(unittest.TestCase): +class RdatasetTestCase(unittest.TestCase): def testCodec2003(self): - r1 = dns.rdataset.from_text_list('in', 'ns', 30, - ['Königsgäßchen']) - r2 = dns.rdataset.from_text_list('in', 'ns', 30, - ['xn--knigsgsschen-lcb0w']) + r1 = dns.rdataset.from_text_list("in", "ns", 30, ["Königsgäßchen"]) + r2 = dns.rdataset.from_text_list("in", "ns", 30, ["xn--knigsgsschen-lcb0w"]) self.assertEqual(r1, r2) - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def testCodec2008(self): - r1 = dns.rdataset.from_text_list('in', 'ns', 30, - ['Königsgäßchen'], - idna_codec=dns.name.IDNA_2008) - r2 = dns.rdataset.from_text_list('in', 'ns', 30, - ['xn--knigsgchen-b4a3dun'], - idna_codec=dns.name.IDNA_2008) + r1 = dns.rdataset.from_text_list( + "in", "ns", 30, ["Königsgäßchen"], idna_codec=dns.name.IDNA_2008 + ) + r2 = dns.rdataset.from_text_list( + "in", "ns", 30, ["xn--knigsgchen-b4a3dun"], idna_codec=dns.name.IDNA_2008 + ) self.assertEqual(r1, r2) def testCopy(self): - r1 = dns.rdataset.from_text_list('in', 'a', 30, - ['10.0.0.1', '10.0.0.2']) + r1 = dns.rdataset.from_text_list("in", "a", 30, ["10.0.0.1", "10.0.0.2"]) r2 = r1.copy() self.assertFalse(r1 is r2) self.assertTrue(r1 == r2) def testAddIncompatible(self): rds = dns.rdataset.Rdataset(dns.rdataclass.IN, dns.rdatatype.A) - rd1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1') - rd2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.AAAA, - '::1') + rd1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1") + rd2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.AAAA, "::1") rds.add(rd1, 30) - self.assertRaises(dns.rdataset.IncompatibleTypes, - lambda: rds.add(rd2, 30)) + self.assertRaises(dns.rdataset.IncompatibleTypes, lambda: rds.add(rd2, 30)) def testDifferingCovers(self): - rds = dns.rdataset.Rdataset(dns.rdataclass.IN, dns.rdatatype.RRSIG, - dns.rdatatype.A) + rds = dns.rdataset.Rdataset( + dns.rdataclass.IN, dns.rdatatype.RRSIG, dns.rdatatype.A + ) rd1 = dns.rdata.from_text( - dns.rdataclass.IN, dns.rdatatype.RRSIG, - 'A 1 3 3600 20200101000000 20030101000000 2143 foo Ym9ndXM=') + dns.rdataclass.IN, + dns.rdatatype.RRSIG, + "A 1 3 3600 20200101000000 20030101000000 2143 foo Ym9ndXM=", + ) rd2 = dns.rdata.from_text( - dns.rdataclass.IN, dns.rdatatype.RRSIG, - 'AAAA 1 3 3600 20200101000000 20030101000000 2143 foo Ym9ndXM=') + dns.rdataclass.IN, + dns.rdatatype.RRSIG, + "AAAA 1 3 3600 20200101000000 20030101000000 2143 foo Ym9ndXM=", + ) rds.add(rd1, 30) - self.assertRaises(dns.rdataset.DifferingCovers, - lambda: rds.add(rd2, 30)) + self.assertRaises(dns.rdataset.DifferingCovers, lambda: rds.add(rd2, 30)) def testUnionUpdate(self): - rds1 = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1') - rds2 = dns.rdataset.from_text('in', 'a', 30, '10.0.0.2') - rdse = dns.rdataset.from_text('in', 'a', 30, '10.0.0.1', '10.0.0.2') + rds1 = dns.rdataset.from_text("in", "a", 300, "10.0.0.1") + rds2 = dns.rdataset.from_text("in", "a", 30, "10.0.0.2") + rdse = dns.rdataset.from_text("in", "a", 30, "10.0.0.1", "10.0.0.2") rds1.union_update(rds2) self.assertEqual(rds1, rdse) def testIntersectionUpdate(self): - rds1 = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1', '10.0.0.2') - rds2 = dns.rdataset.from_text('in', 'a', 30, '10.0.0.2') - rdse = dns.rdataset.from_text('in', 'a', 30, '10.0.0.2') + rds1 = dns.rdataset.from_text("in", "a", 300, "10.0.0.1", "10.0.0.2") + rds2 = dns.rdataset.from_text("in", "a", 30, "10.0.0.2") + rdse = dns.rdataset.from_text("in", "a", 30, "10.0.0.2") rds1.intersection_update(rds2) self.assertEqual(rds1, rdse) def testNoEqualToOther(self): - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1') + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.1") self.assertFalse(rds == 123) def testEmptyRdataList(self): - self.assertRaises(ValueError, - lambda: dns.rdataset.from_rdata_list(300, [])) + self.assertRaises(ValueError, lambda: dns.rdataset.from_rdata_list(300, [])) def testToTextNoName(self): - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1') + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.1") text = rds.to_text() - self.assertEqual(text, '300 IN A 10.0.0.1') + self.assertEqual(text, "300 IN A 10.0.0.1") def testToTextOverrideClass(self): - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1') + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.1") text = rds.to_text(override_rdclass=dns.rdataclass.NONE) - self.assertEqual(text, '300 NONE A 10.0.0.1') + self.assertEqual(text, "300 NONE A 10.0.0.1") def testRepr(self): - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1') + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.1") self.assertEqual(repr(rds), "<DNS IN A rdataset: [<10.0.0.1>]>") def testTruncatedRepr(self): - rds = dns.rdataset.from_text('in', 'txt', 300, - 'a' * 200) + rds = dns.rdataset.from_text("in", "txt", 300, "a" * 200) # * 99 not * 100 below as the " counts as one of the 100 chars - self.assertEqual(repr(rds), - '<DNS IN TXT rdataset: [<"' + 'a' * 99 + '...>]>') + self.assertEqual(repr(rds), '<DNS IN TXT rdataset: [<"' + "a" * 99 + "...>]>") def testStr(self): - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1') + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.1") self.assertEqual(str(rds), "300 IN A 10.0.0.1") def testMultilineToText(self): - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1', '10.0.0.2') + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.1", "10.0.0.2") self.assertEqual(rds.to_text(), "300 IN A 10.0.0.1\n300 IN A 10.0.0.2") def testCoveredRepr(self): - rds = dns.rdataset.from_text('in', 'rrsig', 300, - 'NSEC 1 3 3600 ' + - '20190101000000 20030101000000 ' + - '2143 foo Ym9ndXM=') + rds = dns.rdataset.from_text( + "in", + "rrsig", + 300, + "NSEC 1 3 3600 " + "20190101000000 20030101000000 " + "2143 foo Ym9ndXM=", + ) # Using startswith as I don't care about the repr of the rdata, # just the covers - self.assertTrue(repr(rds).startswith( - '<DNS IN RRSIG(NSEC) rdataset:')) + self.assertTrue(repr(rds).startswith("<DNS IN RRSIG(NSEC) rdataset:")) class ImmutableRdatasetTestCase(unittest.TestCase): - def test_basic(self): - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1', '10.0.0.2') - rd = dns.rdata.from_text('in', 'a', '10.0.0.3') + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.1", "10.0.0.2") + rd = dns.rdata.from_text("in", "a", "10.0.0.3") irds = dns.rdataset.ImmutableRdataset(rds) with self.assertRaises(TypeError): irds.update_ttl(100) @@ -151,13 +147,14 @@ class ImmutableRdatasetTestCase(unittest.TestCase): irds.clear() def test_cloning(self): - rds1 = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1', '10.0.0.2') + rds1 = dns.rdataset.from_text("in", "a", 300, "10.0.0.1", "10.0.0.2") rds1 = dns.rdataset.ImmutableRdataset(rds1) - rds2 = dns.rdataset.from_text('in', 'a', 300, '10.0.0.2', '10.0.0.3') + rds2 = dns.rdataset.from_text("in", "a", 300, "10.0.0.2", "10.0.0.3") rds2 = dns.rdataset.ImmutableRdataset(rds2) - expected = dns.rdataset.from_text('in', 'a', 300, '10.0.0.2') + expected = dns.rdataset.from_text("in", "a", 300, "10.0.0.2") intersection = rds1.intersection(rds2) self.assertEqual(intersection, expected) -if __name__ == '__main__': + +if __name__ == "__main__": unittest.main() diff --git a/tests/test_rdtypeandclass.py b/tests/test_rdtypeandclass.py index e7b6da2..eeb9279 100644 --- a/tests/test_rdtypeandclass.py +++ b/tests/test_rdtypeandclass.py @@ -20,6 +20,7 @@ import unittest import dns.rdataclass import dns.rdatatype + class RdTypeAndClassTestCase(unittest.TestCase): # Classes @@ -31,39 +32,43 @@ class RdTypeAndClassTestCase(unittest.TestCase): self.assertFalse(dns.rdataclass.is_metaclass(dns.rdataclass.IN)) def test_class_bytext1(self): - self.assertEqual(dns.rdataclass.from_text('IN'), dns.rdataclass.IN) + self.assertEqual(dns.rdataclass.from_text("IN"), dns.rdataclass.IN) def test_class_bytext2(self): - self.assertEqual(dns.rdataclass.from_text('CLASS1'), dns.rdataclass.IN) + self.assertEqual(dns.rdataclass.from_text("CLASS1"), dns.rdataclass.IN) def test_class_bytext_bounds1(self): - self.assertEqual(dns.rdataclass.from_text('CLASS0'), 0) - self.assertEqual(dns.rdataclass.from_text('CLASS65535'), 65535) + self.assertEqual(dns.rdataclass.from_text("CLASS0"), 0) + self.assertEqual(dns.rdataclass.from_text("CLASS65535"), 65535) def test_class_bytext_bounds2(self): def bad(): - dns.rdataclass.from_text('CLASS65536') + dns.rdataclass.from_text("CLASS65536") + self.assertRaises(ValueError, bad) def test_class_bytext_unknown(self): def bad(): - dns.rdataclass.from_text('XXX') + dns.rdataclass.from_text("XXX") + self.assertRaises(dns.rdataclass.UnknownRdataclass, bad) def test_class_totext1(self): - self.assertEqual(dns.rdataclass.to_text(dns.rdataclass.IN), 'IN') + self.assertEqual(dns.rdataclass.to_text(dns.rdataclass.IN), "IN") def test_class_totext2(self): - self.assertEqual(dns.rdataclass.to_text(999), 'CLASS999') + self.assertEqual(dns.rdataclass.to_text(999), "CLASS999") def test_class_totext_bounds1(self): def bad(): dns.rdataclass.to_text(-1) + self.assertRaises(ValueError, bad) def test_class_totext_bounds2(self): def bad(): dns.rdataclass.to_text(65536) + self.assertRaises(ValueError, bad) # Types @@ -84,43 +89,48 @@ class RdTypeAndClassTestCase(unittest.TestCase): self.assertFalse(dns.rdatatype.is_singleton(dns.rdatatype.A)) def test_type_bytext1(self): - self.assertEqual(dns.rdatatype.from_text('A'), dns.rdatatype.A) + self.assertEqual(dns.rdatatype.from_text("A"), dns.rdatatype.A) def test_type_bytext2(self): - self.assertEqual(dns.rdatatype.from_text('TYPE1'), dns.rdatatype.A) + self.assertEqual(dns.rdatatype.from_text("TYPE1"), dns.rdatatype.A) def test_type_bytext_bounds1(self): - self.assertEqual(dns.rdatatype.from_text('TYPE0'), 0) - self.assertEqual(dns.rdatatype.from_text('TYPE65535'), 65535) + self.assertEqual(dns.rdatatype.from_text("TYPE0"), 0) + self.assertEqual(dns.rdatatype.from_text("TYPE65535"), 65535) def test_type_bytext_bounds2(self): def bad(): - dns.rdatatype.from_text('TYPE65536') + dns.rdatatype.from_text("TYPE65536") + self.assertRaises(ValueError, bad) def test_type_bytext_unknown(self): def bad(): - dns.rdatatype.from_text('XXX') + dns.rdatatype.from_text("XXX") + self.assertRaises(dns.rdatatype.UnknownRdatatype, bad) def test_type_totext1(self): - self.assertEqual(dns.rdatatype.to_text(dns.rdatatype.A), 'A') + self.assertEqual(dns.rdatatype.to_text(dns.rdatatype.A), "A") def test_type_totext2(self): - self.assertEqual(dns.rdatatype.to_text(999), 'TYPE999') + self.assertEqual(dns.rdatatype.to_text(999), "TYPE999") def test_type_totext_bounds1(self): def bad(): dns.rdatatype.to_text(-1) + self.assertRaises(ValueError, bad) def test_type_totext_bounds2(self): def bad(): dns.rdatatype.to_text(65536) + self.assertRaises(ValueError, bad) def test_type0_totext(self): - self.assertEqual(dns.rdatatype.to_text(0), 'TYPE0') + self.assertEqual(dns.rdatatype.to_text(0), "TYPE0") + -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/tests/test_rdtypeanydnskey.py b/tests/test_rdtypeanydnskey.py index 4ad7683..2981656 100644 --- a/tests/test_rdtypeanydnskey.py +++ b/tests/test_rdtypeanydnskey.py @@ -19,25 +19,28 @@ import unittest import dns.rrset import dns.rdtypes.ANY.DNSKEY -from typing import Set # pylint: disable=unused-import +from typing import Set # pylint: disable=unused-import -class RdtypeAnyDnskeyTestCase(unittest.TestCase): - def testFlagsAll(self): # type: () -> None - '''Test that all defined flags are recognized.''' - good_s = {'SEP', 'REVOKE', 'ZONE'} +class RdtypeAnyDnskeyTestCase(unittest.TestCase): + def testFlagsAll(self): # type: () -> None + """Test that all defined flags are recognized.""" + good_s = {"SEP", "REVOKE", "ZONE"} good_f = 0x181 - self.assertEqual(dns.rdtypes.ANY.DNSKEY.SEP | - dns.rdtypes.ANY.DNSKEY.REVOKE | - dns.rdtypes.ANY.DNSKEY.ZONE, good_f) - - def testFlagsRRToText(self): # type: () -> None - '''Test that RR method returns correct flags.''' - rr = dns.rrset.from_text('foo', 300, 'IN', 'DNSKEY', '257 3 8 KEY=')[0] - self.assertEqual(dns.rdtypes.ANY.DNSKEY.ZONE | - dns.rdtypes.ANY.DNSKEY.SEP, - rr.flags) - - -if __name__ == '__main__': + self.assertEqual( + dns.rdtypes.ANY.DNSKEY.SEP + | dns.rdtypes.ANY.DNSKEY.REVOKE + | dns.rdtypes.ANY.DNSKEY.ZONE, + good_f, + ) + + def testFlagsRRToText(self): # type: () -> None + """Test that RR method returns correct flags.""" + rr = dns.rrset.from_text("foo", 300, "IN", "DNSKEY", "257 3 8 KEY=")[0] + self.assertEqual( + dns.rdtypes.ANY.DNSKEY.ZONE | dns.rdtypes.ANY.DNSKEY.SEP, rr.flags + ) + + +if __name__ == "__main__": unittest.main() diff --git a/tests/test_rdtypeanyeui.py b/tests/test_rdtypeanyeui.py index 0852727..b65442a 100644 --- a/tests/test_rdtypeanyeui.py +++ b/tests/test_rdtypeanyeui.py @@ -24,181 +24,161 @@ import dns.exception class RdtypeAnyEUI48TestCase(unittest.TestCase): def testInstOk(self): - '''Valid binary input.''' - eui = b'\x01\x23\x45\x67\x89\xab' - inst = dns.rdtypes.ANY.EUI48.EUI48(dns.rdataclass.IN, - dns.rdatatype.EUI48, - eui) + """Valid binary input.""" + eui = b"\x01\x23\x45\x67\x89\xab" + inst = dns.rdtypes.ANY.EUI48.EUI48(dns.rdataclass.IN, dns.rdatatype.EUI48, eui) self.assertEqual(inst.eui, eui) def testInstLength(self): - '''Incorrect input length.''' - eui = b'\x01\x23\x45\x67\x89\xab\xcd' + """Incorrect input length.""" + eui = b"\x01\x23\x45\x67\x89\xab\xcd" with self.assertRaises(dns.exception.FormError): - dns.rdtypes.ANY.EUI48.EUI48(dns.rdataclass.IN, - dns.rdatatype.EUI48, - eui) + dns.rdtypes.ANY.EUI48.EUI48(dns.rdataclass.IN, dns.rdatatype.EUI48, eui) def testFromTextOk(self): - '''Valid text input.''' - r1 = dns.rrset.from_text('foo', 300, 'IN', 'EUI48', - '01-23-45-67-89-ab') - eui = b'\x01\x23\x45\x67\x89\xab' + """Valid text input.""" + r1 = dns.rrset.from_text("foo", 300, "IN", "EUI48", "01-23-45-67-89-ab") + eui = b"\x01\x23\x45\x67\x89\xab" self.assertEqual(r1[0].eui, eui) def testFromTextLength(self): - '''Invalid input length.''' + """Invalid input length.""" with self.assertRaises(dns.exception.SyntaxError): - dns.rrset.from_text('foo', 300, 'IN', 'EUI48', - '00-01-23-45-67-89-ab') + dns.rrset.from_text("foo", 300, "IN", "EUI48", "00-01-23-45-67-89-ab") def testFromTextDelim(self): - '''Invalid delimiter.''' + """Invalid delimiter.""" with self.assertRaises(dns.exception.SyntaxError): - dns.rrset.from_text('foo', 300, 'IN', 'EUI48', '01_23-45-67-89-ab') + dns.rrset.from_text("foo", 300, "IN", "EUI48", "01_23-45-67-89-ab") def testFromTextExtraDash(self): - '''Extra dash instead of hex digit.''' + """Extra dash instead of hex digit.""" with self.assertRaises(dns.exception.SyntaxError): - dns.rrset.from_text('foo', 300, 'IN', 'EUI48', '0--23-45-67-89-ab') + dns.rrset.from_text("foo", 300, "IN", "EUI48", "0--23-45-67-89-ab") def testFromTextMultipleTokens(self): - '''Invalid input divided to multiple tokens.''' + """Invalid input divided to multiple tokens.""" with self.assertRaises(dns.exception.SyntaxError): - dns.rrset.from_text('foo', 300, 'IN', 'EUI48', '01 23-45-67-89-ab') + dns.rrset.from_text("foo", 300, "IN", "EUI48", "01 23-45-67-89-ab") def testFromTextInvalidHex(self): - '''Invalid hexadecimal input.''' + """Invalid hexadecimal input.""" with self.assertRaises(dns.exception.SyntaxError): - dns.rrset.from_text('foo', 300, 'IN', 'EUI48', 'g0-23-45-67-89-ab') + dns.rrset.from_text("foo", 300, "IN", "EUI48", "g0-23-45-67-89-ab") def testToTextOk(self): - '''Valid text output.''' - eui = b'\x01\x23\x45\x67\x89\xab' - exp_text = '01-23-45-67-89-ab' - inst = dns.rdtypes.ANY.EUI48.EUI48(dns.rdataclass.IN, - dns.rdatatype.EUI48, - eui) + """Valid text output.""" + eui = b"\x01\x23\x45\x67\x89\xab" + exp_text = "01-23-45-67-89-ab" + inst = dns.rdtypes.ANY.EUI48.EUI48(dns.rdataclass.IN, dns.rdatatype.EUI48, eui) text = inst.to_text() self.assertEqual(exp_text, text) def testToWire(self): - '''Valid wire format.''' - eui = b'\x01\x23\x45\x67\x89\xab' - inst = dns.rdtypes.ANY.EUI48.EUI48(dns.rdataclass.IN, - dns.rdatatype.EUI48, - eui) + """Valid wire format.""" + eui = b"\x01\x23\x45\x67\x89\xab" + inst = dns.rdtypes.ANY.EUI48.EUI48(dns.rdataclass.IN, dns.rdatatype.EUI48, eui) self.assertEqual(inst.to_wire(), eui) def testFromWireOk(self): - '''Valid wire format.''' - eui = b'\x01\x23\x45\x67\x89\xab' + """Valid wire format.""" + eui = b"\x01\x23\x45\x67\x89\xab" pad_len = 100 - wire = b'x' * pad_len + eui + b'y' * pad_len * 2 - inst = dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.EUI48, - wire, pad_len, len(eui)) + wire = b"x" * pad_len + eui + b"y" * pad_len * 2 + inst = dns.rdata.from_wire( + dns.rdataclass.IN, dns.rdatatype.EUI48, wire, pad_len, len(eui) + ) self.assertEqual(inst.eui, eui) def testFromWireLength(self): - '''Valid wire format.''' - eui = b'\x01\x23\x45\x67\x89' + """Valid wire format.""" + eui = b"\x01\x23\x45\x67\x89" pad_len = 100 - wire = b'x' * pad_len + eui + b'y' * pad_len * 2 + wire = b"x" * pad_len + eui + b"y" * pad_len * 2 with self.assertRaises(dns.exception.FormError): - dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.EUI48, - wire, pad_len, len(eui)) + dns.rdata.from_wire( + dns.rdataclass.IN, dns.rdatatype.EUI48, wire, pad_len, len(eui) + ) class RdtypeAnyEUI64TestCase(unittest.TestCase): def testInstOk(self): - '''Valid binary input.''' - eui = b'\x01\x23\x45\x67\x89\xab\xcd\xef' - inst = dns.rdtypes.ANY.EUI64.EUI64(dns.rdataclass.IN, - dns.rdatatype.EUI64, - eui) + """Valid binary input.""" + eui = b"\x01\x23\x45\x67\x89\xab\xcd\xef" + inst = dns.rdtypes.ANY.EUI64.EUI64(dns.rdataclass.IN, dns.rdatatype.EUI64, eui) self.assertEqual(inst.eui, eui) def testInstLength(self): - '''Incorrect input length.''' - eui = b'\x01\x23\x45\x67\x89\xab' + """Incorrect input length.""" + eui = b"\x01\x23\x45\x67\x89\xab" with self.assertRaises(dns.exception.FormError): - dns.rdtypes.ANY.EUI64.EUI64(dns.rdataclass.IN, - dns.rdatatype.EUI64, - eui) + dns.rdtypes.ANY.EUI64.EUI64(dns.rdataclass.IN, dns.rdatatype.EUI64, eui) def testFromTextOk(self): - '''Valid text input.''' - r1 = dns.rrset.from_text('foo', 300, 'IN', 'EUI64', - '01-23-45-67-89-ab-cd-ef') - eui = b'\x01\x23\x45\x67\x89\xab\xcd\xef' + """Valid text input.""" + r1 = dns.rrset.from_text("foo", 300, "IN", "EUI64", "01-23-45-67-89-ab-cd-ef") + eui = b"\x01\x23\x45\x67\x89\xab\xcd\xef" self.assertEqual(r1[0].eui, eui) def testFromTextLength(self): - '''Invalid input length.''' + """Invalid input length.""" with self.assertRaises(dns.exception.SyntaxError): - dns.rrset.from_text('foo', 300, 'IN', 'EUI64', - '01-23-45-67-89-ab') + dns.rrset.from_text("foo", 300, "IN", "EUI64", "01-23-45-67-89-ab") def testFromTextDelim(self): - '''Invalid delimiter.''' + """Invalid delimiter.""" with self.assertRaises(dns.exception.SyntaxError): - dns.rrset.from_text('foo', 300, 'IN', 'EUI64', - '01_23-45-67-89-ab-cd-ef') + dns.rrset.from_text("foo", 300, "IN", "EUI64", "01_23-45-67-89-ab-cd-ef") def testFromTextExtraDash(self): - '''Extra dash instead of hex digit.''' + """Extra dash instead of hex digit.""" with self.assertRaises(dns.exception.SyntaxError): - dns.rrset.from_text('foo', 300, 'IN', 'EUI64', - '0--23-45-67-89-ab-cd-ef') + dns.rrset.from_text("foo", 300, "IN", "EUI64", "0--23-45-67-89-ab-cd-ef") def testFromTextMultipleTokens(self): - '''Invalid input divided to multiple tokens.''' + """Invalid input divided to multiple tokens.""" with self.assertRaises(dns.exception.SyntaxError): - dns.rrset.from_text('foo', 300, 'IN', 'EUI64', - '01 23-45-67-89-ab-cd-ef') + dns.rrset.from_text("foo", 300, "IN", "EUI64", "01 23-45-67-89-ab-cd-ef") def testFromTextInvalidHex(self): - '''Invalid hexadecimal input.''' + """Invalid hexadecimal input.""" with self.assertRaises(dns.exception.SyntaxError): - dns.rrset.from_text('foo', 300, 'IN', 'EUI64', - 'g0-23-45-67-89-ab-cd-ef') + dns.rrset.from_text("foo", 300, "IN", "EUI64", "g0-23-45-67-89-ab-cd-ef") def testToTextOk(self): - '''Valid text output.''' - eui = b'\x01\x23\x45\x67\x89\xab\xcd\xef' - exp_text = '01-23-45-67-89-ab-cd-ef' - inst = dns.rdtypes.ANY.EUI64.EUI64(dns.rdataclass.IN, - dns.rdatatype.EUI64, - eui) + """Valid text output.""" + eui = b"\x01\x23\x45\x67\x89\xab\xcd\xef" + exp_text = "01-23-45-67-89-ab-cd-ef" + inst = dns.rdtypes.ANY.EUI64.EUI64(dns.rdataclass.IN, dns.rdatatype.EUI64, eui) text = inst.to_text() self.assertEqual(exp_text, text) def testToWire(self): - '''Valid wire format.''' - eui = b'\x01\x23\x45\x67\x89\xab\xcd\xef' - inst = dns.rdtypes.ANY.EUI64.EUI64(dns.rdataclass.IN, - dns.rdatatype.EUI64, - eui) + """Valid wire format.""" + eui = b"\x01\x23\x45\x67\x89\xab\xcd\xef" + inst = dns.rdtypes.ANY.EUI64.EUI64(dns.rdataclass.IN, dns.rdatatype.EUI64, eui) self.assertEqual(inst.to_wire(), eui) def testFromWireOk(self): - '''Valid wire format.''' - eui = b'\x01\x23\x45\x67\x89\xab\xcd\xef' + """Valid wire format.""" + eui = b"\x01\x23\x45\x67\x89\xab\xcd\xef" pad_len = 100 - wire = b'x' * pad_len + eui + b'y' * pad_len * 2 - inst = dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.EUI64, - wire, pad_len, len(eui)) + wire = b"x" * pad_len + eui + b"y" * pad_len * 2 + inst = dns.rdata.from_wire( + dns.rdataclass.IN, dns.rdatatype.EUI64, wire, pad_len, len(eui) + ) self.assertEqual(inst.eui, eui) def testFromWireLength(self): - '''Valid wire format.''' - eui = b'\x01\x23\x45\x67\x89' + """Valid wire format.""" + eui = b"\x01\x23\x45\x67\x89" pad_len = 100 - wire = b'x' * pad_len + eui + b'y' * pad_len * 2 + wire = b"x" * pad_len + eui + b"y" * pad_len * 2 with self.assertRaises(dns.exception.FormError): - dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.EUI64, - wire, pad_len, len(eui)) + dns.rdata.from_wire( + dns.rdataclass.IN, dns.rdatatype.EUI64, wire, pad_len, len(eui) + ) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/tests/test_rdtypeanyloc.py b/tests/test_rdtypeanyloc.py index 23a1f68..8fe210b 100644 --- a/tests/test_rdtypeanyloc.py +++ b/tests/test_rdtypeanyloc.py @@ -19,52 +19,84 @@ import unittest import dns.rrset import dns.rdtypes.ANY.LOC -class RdtypeAnyLocTestCase(unittest.TestCase): +class RdtypeAnyLocTestCase(unittest.TestCase): def testEqual1(self): - '''Test default values for size, horizontal and vertical precision.''' - r1 = dns.rrset.from_text('foo', 300, 'IN', 'LOC', - '49 11 42.400 N 16 36 29.600 E 227.64m') - r2 = dns.rrset.from_text('FOO', 600, 'in', 'loc', - '49 11 42.400 N 16 36 29.600 E 227.64m ' - '1.00m 10000.00m 10.00m') + """Test default values for size, horizontal and vertical precision.""" + r1 = dns.rrset.from_text( + "foo", 300, "IN", "LOC", "49 11 42.400 N 16 36 29.600 E 227.64m" + ) + r2 = dns.rrset.from_text( + "FOO", + 600, + "in", + "loc", + "49 11 42.400 N 16 36 29.600 E 227.64m " "1.00m 10000.00m 10.00m", + ) self.assertEqual(r1, r2, '"{}" != "{}"'.format(r1, r2)) def testEqual2(self): - '''Test default values for size, horizontal and vertical precision.''' - r1 = dns.rdtypes.ANY.LOC.LOC(1, 29, (49, 11, 42, 400, 1), - (16, 36, 29, 600, 1), - 22764.0) # centimeters - r2 = dns.rdtypes.ANY.LOC.LOC(1, 29, (49, 11, 42, 400, 1), - (16, 36, 29, 600, 1), - 22764.0, # centimeters - 100.0, 1000000.00, 1000.0) # centimeters + """Test default values for size, horizontal and vertical precision.""" + r1 = dns.rdtypes.ANY.LOC.LOC( + 1, 29, (49, 11, 42, 400, 1), (16, 36, 29, 600, 1), 22764.0 + ) # centimeters + r2 = dns.rdtypes.ANY.LOC.LOC( + 1, + 29, + (49, 11, 42, 400, 1), + (16, 36, 29, 600, 1), + 22764.0, # centimeters + 100.0, + 1000000.00, + 1000.0, + ) # centimeters self.assertEqual(r1, r2, '"{}" != "{}"'.format(r1, r2)) def testEqual3(self): - '''Test size, horizontal and vertical precision parsers: 100 cm == 1 m. + """Test size, horizontal and vertical precision parsers: 100 cm == 1 m. - Parsers in from_text() and __init__() have to produce equal results.''' - r1 = dns.rdtypes.ANY.LOC.LOC(1, 29, (49, 11, 42, 400, 1), - (16, 36, 29, 600, 1), 22764.0, - 200.0, 1000.00, 200.0) # centimeters - r2 = dns.rrset.from_text('FOO', 600, 'in', 'loc', - '49 11 42.400 N 16 36 29.600 E 227.64m ' - '2.00m 10.00m 2.00m')[0] + Parsers in from_text() and __init__() have to produce equal results.""" + r1 = dns.rdtypes.ANY.LOC.LOC( + 1, + 29, + (49, 11, 42, 400, 1), + (16, 36, 29, 600, 1), + 22764.0, + 200.0, + 1000.00, + 200.0, + ) # centimeters + r2 = dns.rrset.from_text( + "FOO", + 600, + "in", + "loc", + "49 11 42.400 N 16 36 29.600 E 227.64m " "2.00m 10.00m 2.00m", + )[0] self.assertEqual(r1, r2, '"{}" != "{}"'.format(r1, r2)) def testEqual4(self): - '''Test size, horizontal and vertical precision parsers without unit. + """Test size, horizontal and vertical precision parsers without unit. Parsers in from_text() and __init__() have produce equal result - for values with and without trailing "m".''' - r1 = dns.rdtypes.ANY.LOC.LOC(1, 29, (49, 11, 42, 400, 1), - (16, 36, 29, 600, 1), 22764.0, - 200.0, 1000.00, 200.0) # centimeters - r2 = dns.rrset.from_text('FOO', 600, 'in', 'loc', - '49 11 42.400 N 16 36 29.600 E 227.64 ' - '2 10 2')[0] # meters without explicit unit + for values with and without trailing "m".""" + r1 = dns.rdtypes.ANY.LOC.LOC( + 1, + 29, + (49, 11, 42, 400, 1), + (16, 36, 29, 600, 1), + 22764.0, + 200.0, + 1000.00, + 200.0, + ) # centimeters + r2 = dns.rrset.from_text( + "FOO", 600, "in", "loc", "49 11 42.400 N 16 36 29.600 E 227.64 " "2 10 2" + )[ + 0 + ] # meters without explicit unit self.assertEqual(r1, r2, '"{}" != "{}"'.format(r1, r2)) -if __name__ == '__main__': + +if __name__ == "__main__": unittest.main() diff --git a/tests/test_rdtypeanytkey.py b/tests/test_rdtypeanytkey.py index 3a3ca57..f3d7007 100644 --- a/tests/test_rdtypeanytkey.py +++ b/tests/test_rdtypeanytkey.py @@ -27,70 +27,94 @@ from dns.rdatatype import RdataType class RdtypeAnyTKeyTestCase(unittest.TestCase): - tkey_rdata_text = 'gss-tsig. 1594203795 1594206664 3 0 KEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEY OTHEROTHEROTHEROTHEROTHEROTHEROT' - tkey_rdata_text_no_other = 'gss-tsig. 1594203795 1594206664 3 0 KEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEY' + tkey_rdata_text = "gss-tsig. 1594203795 1594206664 3 0 KEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEY OTHEROTHEROTHEROTHEROTHEROTHEROT" + tkey_rdata_text_no_other = ( + "gss-tsig. 1594203795 1594206664 3 0 KEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEY" + ) def testTextOptionalData(self): # construct the rdata from text and extract the TKEY tkey = dns.rdata.from_text( - RdataClass.ANY, RdataType.TKEY, - RdtypeAnyTKeyTestCase.tkey_rdata_text, origin='.') + RdataClass.ANY, + RdataType.TKEY, + RdtypeAnyTKeyTestCase.tkey_rdata_text, + origin=".", + ) self.assertEqual(type(tkey), dns.rdtypes.ANY.TKEY.TKEY) # go to text and compare tkey_out_text = tkey.to_text(relativize=False) - self.assertEqual(tkey_out_text, - RdtypeAnyTKeyTestCase.tkey_rdata_text) + self.assertEqual(tkey_out_text, RdtypeAnyTKeyTestCase.tkey_rdata_text) def testTextNoOptionalData(self): # construct the rdata from text and extract the TKEY tkey = dns.rdata.from_text( - RdataClass.ANY, RdataType.TKEY, - RdtypeAnyTKeyTestCase.tkey_rdata_text_no_other, origin='.') + RdataClass.ANY, + RdataType.TKEY, + RdtypeAnyTKeyTestCase.tkey_rdata_text_no_other, + origin=".", + ) self.assertEqual(type(tkey), dns.rdtypes.ANY.TKEY.TKEY) # go to text and compare tkey_out_text = tkey.to_text(relativize=False) - self.assertEqual(tkey_out_text, - RdtypeAnyTKeyTestCase.tkey_rdata_text_no_other) + self.assertEqual(tkey_out_text, RdtypeAnyTKeyTestCase.tkey_rdata_text_no_other) def testWireOptionalData(self): - key = base64.b64decode('KEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEY') - other = base64.b64decode('OTHEROTHEROTHEROTHEROTHEROTHEROT') + key = base64.b64decode("KEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEY") + other = base64.b64decode("OTHEROTHEROTHEROTHEROTHEROTHEROT") # construct the TKEY and compare the text output - tkey = dns.rdtypes.ANY.TKEY.TKEY(dns.rdataclass.ANY, - dns.rdatatype.TKEY, - dns.name.from_text('gss-tsig.'), - 1594203795, 1594206664, - 3, 0, key, other) - self.assertEqual(tkey.to_text(relativize=False), - RdtypeAnyTKeyTestCase.tkey_rdata_text) + tkey = dns.rdtypes.ANY.TKEY.TKEY( + dns.rdataclass.ANY, + dns.rdatatype.TKEY, + dns.name.from_text("gss-tsig."), + 1594203795, + 1594206664, + 3, + 0, + key, + other, + ) + self.assertEqual( + tkey.to_text(relativize=False), RdtypeAnyTKeyTestCase.tkey_rdata_text + ) # go to/from wire and compare the text output wire = tkey.to_wire() - tkey_out_wire = dns.rdata.from_wire(dns.rdataclass.ANY, - dns.rdatatype.TKEY, - wire, 0, len(wire)) - self.assertEqual(tkey_out_wire.to_text(relativize=False), - RdtypeAnyTKeyTestCase.tkey_rdata_text) + tkey_out_wire = dns.rdata.from_wire( + dns.rdataclass.ANY, dns.rdatatype.TKEY, wire, 0, len(wire) + ) + self.assertEqual( + tkey_out_wire.to_text(relativize=False), + RdtypeAnyTKeyTestCase.tkey_rdata_text, + ) def testWireNoOptionalData(self): - key = base64.b64decode('KEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEY') + key = base64.b64decode("KEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEY") # construct the TKEY with no 'other' data and compare the text output - tkey = dns.rdtypes.ANY.TKEY.TKEY(dns.rdataclass.ANY, - dns.rdatatype.TKEY, - dns.name.from_text('gss-tsig.'), - 1594203795, 1594206664, - 3, 0, key) - self.assertEqual(tkey.to_text(relativize=False), - RdtypeAnyTKeyTestCase.tkey_rdata_text_no_other) + tkey = dns.rdtypes.ANY.TKEY.TKEY( + dns.rdataclass.ANY, + dns.rdatatype.TKEY, + dns.name.from_text("gss-tsig."), + 1594203795, + 1594206664, + 3, + 0, + key, + ) + self.assertEqual( + tkey.to_text(relativize=False), + RdtypeAnyTKeyTestCase.tkey_rdata_text_no_other, + ) # go to/from wire and compare the text output wire = tkey.to_wire() - tkey_out_wire = dns.rdata.from_wire(dns.rdataclass.ANY, - dns.rdatatype.TKEY, - wire, 0, len(wire)) - self.assertEqual(tkey_out_wire.to_text(relativize=False), - RdtypeAnyTKeyTestCase.tkey_rdata_text_no_other) + tkey_out_wire = dns.rdata.from_wire( + dns.rdataclass.ANY, dns.rdatatype.TKEY, wire, 0, len(wire) + ) + self.assertEqual( + tkey_out_wire.to_text(relativize=False), + RdtypeAnyTKeyTestCase.tkey_rdata_text_no_other, + ) diff --git a/tests/test_renderer.py b/tests/test_renderer.py index c60ccf9..ca5a85e 100644 --- a/tests/test_renderer.py +++ b/tests/test_renderer.py @@ -9,8 +9,7 @@ import dns.renderer import dns.tsig import dns.tsigkeyring -basic_answer = \ - """flags QR +basic_answer = """flags QR edns 0 payload 4096 ;QUESTION @@ -20,12 +19,13 @@ foo.example. 30 IN A 10.0.0.1 foo.example. 30 IN A 10.0.0.2 """ + class RendererTestCase(unittest.TestCase): def test_basic(self): r = dns.renderer.Renderer(flags=dns.flags.QR, max_size=512) - qname = dns.name.from_text('foo.example') + qname = dns.name.from_text("foo.example") r.add_question(qname, dns.rdatatype.A) - rds = dns.rdataset.from_text('in', 'a', 30, '10.0.0.1', '10.0.0.2') + rds = dns.rdataset.from_text("in", "a", 30, "10.0.0.1", "10.0.0.2") r.add_rdataset(dns.renderer.ANSWER, qname, rds) r.add_edns(0, 0, 4096) r.write_header() @@ -39,13 +39,14 @@ class RendererTestCase(unittest.TestCase): def test_tsig(self): r = dns.renderer.Renderer(flags=dns.flags.RD, max_size=512) - qname = dns.name.from_text('foo.example') + qname = dns.name.from_text("foo.example") r.add_question(qname, dns.rdatatype.A) - keyring = dns.tsigkeyring.from_text({'key' : '12345678'}) + keyring = dns.tsigkeyring.from_text({"key": "12345678"}) keyname = next(iter(keyring)) r.write_header() - r.add_tsig(keyname, keyring[keyname], 300, r.id, 0, b'', b'', - dns.tsig.HMAC_SHA256) + r.add_tsig( + keyname, keyring[keyname], 300, r.id, 0, b"", b"", dns.tsig.HMAC_SHA256 + ) wire = r.get_wire() message = dns.message.from_wire(wire, keyring=keyring) expected = dns.message.make_query(qname, dns.rdatatype.A) @@ -53,15 +54,24 @@ class RendererTestCase(unittest.TestCase): self.assertEqual(message, expected) def test_multi_tsig(self): - qname = dns.name.from_text('foo.example') - keyring = dns.tsigkeyring.from_text({'key' : '12345678'}) + qname = dns.name.from_text("foo.example") + keyring = dns.tsigkeyring.from_text({"key": "12345678"}) keyname = next(iter(keyring)) r = dns.renderer.Renderer(flags=dns.flags.RD, max_size=512) r.add_question(qname, dns.rdatatype.A) r.write_header() - ctx = r.add_multi_tsig(None, keyname, keyring[keyname], 300, r.id, 0, - b'', b'', dns.tsig.HMAC_SHA256) + ctx = r.add_multi_tsig( + None, + keyname, + keyring[keyname], + 300, + r.id, + 0, + b"", + b"", + dns.tsig.HMAC_SHA256, + ) wire = r.get_wire() message = dns.message.from_wire(wire, keyring=keyring, multi=True) expected = dns.message.make_query(qname, dns.rdatatype.A) @@ -71,22 +81,25 @@ class RendererTestCase(unittest.TestCase): r = dns.renderer.Renderer(flags=dns.flags.RD, max_size=512) r.add_question(qname, dns.rdatatype.A) r.write_header() - ctx = r.add_multi_tsig(ctx, keyname, keyring[keyname], 300, r.id, 0, - b'', b'', dns.tsig.HMAC_SHA256) + ctx = r.add_multi_tsig( + ctx, keyname, keyring[keyname], 300, r.id, 0, b"", b"", dns.tsig.HMAC_SHA256 + ) wire = r.get_wire() - message = dns.message.from_wire(wire, keyring=keyring, - tsig_ctx=message.tsig_ctx, multi=True) + message = dns.message.from_wire( + wire, keyring=keyring, tsig_ctx=message.tsig_ctx, multi=True + ) expected = dns.message.make_query(qname, dns.rdatatype.A) expected.id = message.id self.assertEqual(message, expected) - def test_going_backwards_fails(self): r = dns.renderer.Renderer(flags=dns.flags.QR, max_size=512) - qname = dns.name.from_text('foo.example') + qname = dns.name.from_text("foo.example") r.add_question(qname, dns.rdatatype.A) r.add_edns(0, 0, 4096) - rds = dns.rdataset.from_text('in', 'a', 30, '10.0.0.1', '10.0.0.2') + rds = dns.rdataset.from_text("in", "a", 30, "10.0.0.1", "10.0.0.2") + def bad(): r.add_rdataset(dns.renderer.ANSWER, qname, rds) + self.assertRaises(dns.exception.FormError, bad) diff --git a/tests/test_resolution.py b/tests/test_resolution.py index 731090b..d2819a1 100644 --- a/tests/test_resolution.py +++ b/tests/test_resolution.py @@ -13,15 +13,16 @@ import dns.tsigkeyring # Test the resolver's Resolution, i.e. the business logic of the resolver. + class ResolutionTestCase(unittest.TestCase): def setUp(self): self.resolver = dns.resolver.Resolver(configure=False) - self.resolver.nameservers = ['10.0.0.1', '10.0.0.2'] - self.resolver.domain = dns.name.from_text('example') - self.qname = dns.name.from_text('www.dnspython.org') - self.resn = dns.resolver._Resolution(self.resolver, self.qname, - 'A', 'IN', - False, True, False) + self.resolver.nameservers = ["10.0.0.1", "10.0.0.2"] + self.resolver.domain = dns.name.from_text("example") + self.qname = dns.name.from_text("www.dnspython.org") + self.resn = dns.resolver._Resolution( + self.resolver, self.qname, "A", "IN", False, True, False + ) def test_next_request_abs(self): (request, answer) = self.resn.next_request() @@ -30,11 +31,11 @@ class ResolutionTestCase(unittest.TestCase): self.assertEqual(request.question[0].rdtype, dns.rdatatype.A) def test_next_request_rel_with_search(self): - qname = dns.name.from_text('www.dnspython.org', None) - abs_qname_1 = dns.name.from_text('www.dnspython.org.example') - self.resn = dns.resolver._Resolution(self.resolver, qname, - 'A', 'IN', - False, True, True) + qname = dns.name.from_text("www.dnspython.org", None) + abs_qname_1 = dns.name.from_text("www.dnspython.org.example") + self.resn = dns.resolver._Resolution( + self.resolver, qname, "A", "IN", False, True, True + ) (request, answer) = self.resn.next_request() self.assertTrue(answer is None) self.assertEqual(request.question[0].name, self.qname) @@ -43,44 +44,60 @@ class ResolutionTestCase(unittest.TestCase): self.assertTrue(answer is None) self.assertEqual(request.question[0].name, abs_qname_1) self.assertEqual(request.question[0].rdtype, dns.rdatatype.A) + def bad(): (request, answer) = self.resn.next_request() + self.assertRaises(dns.resolver.NXDOMAIN, bad) def test_next_request_rel_without_search(self): - qname = dns.name.from_text('www.dnspython.org', None) - abs_qname_1 = dns.name.from_text('www.dnspython.org.example') - self.resn = dns.resolver._Resolution(self.resolver, qname, - 'A', 'IN', - False, True, False) + qname = dns.name.from_text("www.dnspython.org", None) + abs_qname_1 = dns.name.from_text("www.dnspython.org.example") + self.resn = dns.resolver._Resolution( + self.resolver, qname, "A", "IN", False, True, False + ) (request, answer) = self.resn.next_request() self.assertTrue(answer is None) self.assertEqual(request.question[0].name, self.qname) self.assertEqual(request.question[0].rdtype, dns.rdatatype.A) + def bad(): (request, answer) = self.resn.next_request() + self.assertRaises(dns.resolver.NXDOMAIN, bad) def test_next_request_exhaust_causes_nxdomain(self): def bad(): (request, answer) = self.resn.next_request() + (request, answer) = self.resn.next_request() self.assertRaises(dns.resolver.NXDOMAIN, bad) def make_address_response(self, q): r = dns.message.make_response(q) - rrs = r.get_rrset(r.answer, self.qname, dns.rdataclass.IN, - dns.rdatatype.A, create=True) - rrs.add(dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1'), 300) + rrs = r.get_rrset( + r.answer, self.qname, dns.rdataclass.IN, dns.rdatatype.A, create=True + ) + rrs.add( + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1"), 300 + ) return r def make_negative_response(self, q, nxdomain=False): r = dns.message.make_response(q) - rrs = r.get_rrset(r.authority, q.question[0].name, dns.rdataclass.IN, - dns.rdatatype.SOA, create=True) - rrs.add(dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, - '. . 1 2 3 4 300'), 300) + rrs = r.get_rrset( + r.authority, + q.question[0].name, + dns.rdataclass.IN, + dns.rdatatype.SOA, + create=True, + ) + rrs.add( + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SOA, ". . 1 2 3 4 300" + ), + 300, + ) if nxdomain: r.set_rcode(dns.rcode.NXDOMAIN) return r @@ -89,26 +106,33 @@ class ResolutionTestCase(unittest.TestCase): r = dns.message.make_response(q) name = self.qname for i in range(count): - rrs = r.get_rrset(r.answer, name, dns.rdataclass.IN, - dns.rdatatype.CNAME, create=True) - tname = dns.name.from_text(f'target{i}.') - rrs.add(dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME, - str(tname)), 300) + rrs = r.get_rrset( + r.answer, name, dns.rdataclass.IN, dns.rdatatype.CNAME, create=True + ) + tname = dns.name.from_text(f"target{i}.") + rrs.add( + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME, str(tname)), + 300, + ) name = tname - rrs = r.get_rrset(r.answer, name, dns.rdataclass.IN, - dns.rdatatype.A, create=True) - rrs.add(dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1'), 300) + rrs = r.get_rrset( + r.answer, name, dns.rdataclass.IN, dns.rdatatype.A, create=True + ) + rrs.add( + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1"), 300 + ) return r def test_next_request_cache_hit(self): self.resolver.cache = dns.resolver.Cache() q = dns.message.make_query(self.qname, dns.rdatatype.A) r = self.make_address_response(q) - cache_answer = dns.resolver.Answer(self.qname, dns.rdatatype.A, - dns.rdataclass.IN, r) - self.resolver.cache.put((self.qname, dns.rdatatype.A, - dns.rdataclass.IN), cache_answer) + cache_answer = dns.resolver.Answer( + self.qname, dns.rdatatype.A, dns.rdataclass.IN, r + ) + self.resolver.cache.put( + (self.qname, dns.rdatatype.A, dns.rdataclass.IN), cache_answer + ) (request, answer) = self.resn.next_request() self.assertTrue(request is None) self.assertTrue(answer is cache_answer) @@ -120,36 +144,42 @@ class ResolutionTestCase(unittest.TestCase): # Note we need an SOA so the cache doesn't expire the answer # immediately, but our negative response code does that. r = self.make_negative_response(q) - cache_answer = dns.resolver.Answer(self.qname, dns.rdatatype.A, - dns.rdataclass.IN, r) - self.resolver.cache.put((self.qname, dns.rdatatype.A, - dns.rdataclass.IN), cache_answer) + cache_answer = dns.resolver.Answer( + self.qname, dns.rdatatype.A, dns.rdataclass.IN, r + ) + self.resolver.cache.put( + (self.qname, dns.rdatatype.A, dns.rdataclass.IN), cache_answer + ) + def bad(): (request, answer) = self.resn.next_request() + self.assertRaises(dns.resolver.NoAnswer, bad) # If raise_on_no_answer is False, we should get a cache hit. - self.resn = dns.resolver._Resolution(self.resolver, self.qname, - 'A', 'IN', - False, False, False) + self.resn = dns.resolver._Resolution( + self.resolver, self.qname, "A", "IN", False, False, False + ) (request, answer) = self.resn.next_request() self.assertTrue(request is None) self.assertTrue(answer is cache_answer) def test_next_request_cached_nxdomain_without_search(self): # use a relative qname - qname = dns.name.from_text('www.dnspython.org', None) - self.resn = dns.resolver._Resolution(self.resolver, qname, - 'A', 'IN', - False, True, False) - qname1 = dns.name.from_text('www.dnspython.org.') + qname = dns.name.from_text("www.dnspython.org", None) + self.resn = dns.resolver._Resolution( + self.resolver, qname, "A", "IN", False, True, False + ) + qname1 = dns.name.from_text("www.dnspython.org.") # Arrange to get NXDOMAIN hits on it. self.resolver.cache = dns.resolver.Cache() q1 = dns.message.make_query(qname1, dns.rdatatype.A) r1 = self.make_negative_response(q1, True) - cache_answer = dns.resolver.Answer(qname1, dns.rdatatype.ANY, - dns.rdataclass.IN, r1) - self.resolver.cache.put((qname1, dns.rdatatype.ANY, - dns.rdataclass.IN), cache_answer) + cache_answer = dns.resolver.Answer( + qname1, dns.rdatatype.ANY, dns.rdataclass.IN, r1 + ) + self.resolver.cache.put( + (qname1, dns.rdatatype.ANY, dns.rdataclass.IN), cache_answer + ) try: (request, answer) = self.resn.next_request() self.assertTrue(False) # should not happen! @@ -158,27 +188,31 @@ class ResolutionTestCase(unittest.TestCase): def test_next_request_cached_nxdomain_with_search(self): # use a relative qname so we have two qnames to try - qname = dns.name.from_text('www.dnspython.org', None) + qname = dns.name.from_text("www.dnspython.org", None) # also enable search mode or we'll only see www.dnspython.org. - self.resn = dns.resolver._Resolution(self.resolver, qname, - 'A', 'IN', - False, True, True) - qname1 = dns.name.from_text('www.dnspython.org.example.') - qname2 = dns.name.from_text('www.dnspython.org.') + self.resn = dns.resolver._Resolution( + self.resolver, qname, "A", "IN", False, True, True + ) + qname1 = dns.name.from_text("www.dnspython.org.example.") + qname2 = dns.name.from_text("www.dnspython.org.") # Arrange to get NXDOMAIN hits on both of those qnames. self.resolver.cache = dns.resolver.Cache() q1 = dns.message.make_query(qname1, dns.rdatatype.A) r1 = self.make_negative_response(q1, True) - cache_answer = dns.resolver.Answer(qname1, dns.rdatatype.ANY, - dns.rdataclass.IN, r1) - self.resolver.cache.put((qname1, dns.rdatatype.ANY, - dns.rdataclass.IN), cache_answer) + cache_answer = dns.resolver.Answer( + qname1, dns.rdatatype.ANY, dns.rdataclass.IN, r1 + ) + self.resolver.cache.put( + (qname1, dns.rdatatype.ANY, dns.rdataclass.IN), cache_answer + ) q2 = dns.message.make_query(qname2, dns.rdatatype.A) r2 = self.make_negative_response(q2, True) - cache_answer = dns.resolver.Answer(qname2, dns.rdatatype.ANY, - dns.rdataclass.IN, r2) - self.resolver.cache.put((qname2, dns.rdatatype.ANY, - dns.rdataclass.IN), cache_answer) + cache_answer = dns.resolver.Answer( + qname2, dns.rdatatype.ANY, dns.rdataclass.IN, r2 + ) + self.resolver.cache.put( + (qname2, dns.rdatatype.ANY, dns.rdataclass.IN), cache_answer + ) try: (request, answer) = self.resn.next_request() self.assertTrue(False) # should not happen! @@ -188,8 +222,8 @@ class ResolutionTestCase(unittest.TestCase): def test_next_request_rotate(self): self.resolver.rotate = True - order1 = ['10.0.0.1', '10.0.0.2'] - order2 = ['10.0.0.2', '10.0.0.1'] + order1 = ["10.0.0.1", "10.0.0.2"] + order2 = ["10.0.0.2", "10.0.0.1"] seen1 = False seen2 = False # We're not interested in testing the randomness, but we'd @@ -197,9 +231,9 @@ class ResolutionTestCase(unittest.TestCase): # both orders at least once. This test can fail even with # correct code, but it is *extremely* unlikely. for count in range(0, 50): - self.resn = dns.resolver._Resolution(self.resolver, self.qname, - 'A', 'IN', - False, True, False) + self.resn = dns.resolver._Resolution( + self.resolver, self.qname, "A", "IN", False, True, False + ) self.resn.next_request() if self.resn.nameservers == order1: seen1 = True @@ -212,11 +246,11 @@ class ResolutionTestCase(unittest.TestCase): self.assertTrue(seen1 and seen2) def test_next_request_TSIG(self): - self.resolver.keyring = dns.tsigkeyring.from_text({ - 'keyname.' : 'NjHwPsMKjdN++dOfE5iAiQ==' - }) + self.resolver.keyring = dns.tsigkeyring.from_text( + {"keyname.": "NjHwPsMKjdN++dOfE5iAiQ=="} + ) (keyname, secret) = next(iter(self.resolver.keyring.items())) - self.resolver.keyname = dns.name.from_text('keyname.') + self.resolver.keyname = dns.name.from_text("keyname.") (request, answer) = self.resn.next_request() self.assertFalse(request is None) self.assertEqual(request.keyring.name, keyname) @@ -283,16 +317,22 @@ class ResolutionTestCase(unittest.TestCase): self.resn.nameservers.remove(nameserver) (nameserver, _, _, _) = self.resn.next_nameserver() self.resn.nameservers.remove(nameserver) + def bad(): (nameserver, _, _, _) = self.resn.next_nameserver() + self.assertRaises(dns.resolver.NoNameservers, bad) def test_query_result_nameserver_removing_exceptions(self): # add some nameservers so we have enough to remove :) - self.resolver.nameservers.extend(['10.0.0.3', '10.0.0.4']) + self.resolver.nameservers.extend(["10.0.0.3", "10.0.0.4"]) (request, _) = self.resn.next_request() - exceptions = [dns.exception.FormError(), EOFError(), - NotImplementedError(), dns.message.Truncated()] + exceptions = [ + dns.exception.FormError(), + EOFError(), + NotImplementedError(), + dns.message.Truncated(), + ] for i in range(4): (nameserver, _, _, _) = self.resn.next_nameserver() if i == 3: @@ -349,8 +389,9 @@ class ResolutionTestCase(unittest.TestCase): (_, _, _, _) = self.resn.next_nameserver() (answer, done) = self.resn.query_result(r, None) self.assertFalse(answer is None) - cache_answer = self.resolver.cache.get((self.qname, dns.rdatatype.A, - dns.rdataclass.IN)) + cache_answer = self.resolver.cache.get( + (self.qname, dns.rdatatype.A, dns.rdataclass.IN) + ) self.assertTrue(answer is cache_answer) def test_query_result_no_error_no_data(self): @@ -358,8 +399,10 @@ class ResolutionTestCase(unittest.TestCase): r = self.make_negative_response(q) (_, _) = self.resn.next_request() (_, _, _, _) = self.resn.next_nameserver() + def bad(): (answer, done) = self.resn.query_result(r, None) + self.assertRaises(dns.resolver.NoAnswer, bad) def test_query_result_nxdomain(self): @@ -410,8 +453,9 @@ class ResolutionTestCase(unittest.TestCase): (answer, done) = self.resn.query_result(r, None) self.assertTrue(answer is None) self.assertTrue(done) - cache_answer = self.resolver.cache.get((self.qname, dns.rdatatype.ANY, - dns.rdataclass.IN)) + cache_answer = self.resolver.cache.get( + (self.qname, dns.rdatatype.ANY, dns.rdataclass.IN) + ) self.assertTrue(cache_answer.response is r) def test_query_result_yxdomain(self): @@ -420,8 +464,10 @@ class ResolutionTestCase(unittest.TestCase): r.set_rcode(dns.rcode.YXDOMAIN) (_, _) = self.resn.next_request() (_, _, _, _) = self.resn.next_nameserver() + def bad(): (answer, done) = self.resn.query_result(r, None) + self.assertRaises(dns.resolver.YXDOMAIN, bad) def test_query_result_servfail_no_retry(self): @@ -461,12 +507,14 @@ class ResolutionTestCase(unittest.TestCase): def test_no_metaqueries(self): def bad1(): - self.resn = dns.resolver._Resolution(self.resolver, self.qname, - 'ANY', 'IN', - False, True, False) + self.resn = dns.resolver._Resolution( + self.resolver, self.qname, "ANY", "IN", False, True, False + ) + def bad2(): - self.resn = dns.resolver._Resolution(self.resolver, self.qname, - 'A', 'ANY', - False, True, False) + self.resn = dns.resolver._Resolution( + self.resolver, self.qname, "A", "ANY", False, True, False + ) + self.assertRaises(dns.resolver.NoMetaqueries, bad1) self.assertRaises(dns.resolver.NoMetaqueries, bad2) diff --git a/tests/test_resolver.py b/tests/test_resolver.py index 0f6a638..dc2dde4 100644 --- a/tests/test_resolver.py +++ b/tests/test_resolver.py @@ -37,7 +37,7 @@ import dns.tsigkeyring # skip those if it's not there. _network_available = True try: - socket.gethostbyname('dnspython.org') + socket.gethostbyname("dnspython.org") except socket.gaierror: _network_available = False @@ -46,25 +46,28 @@ except socket.gaierror: # those tests. try: from .nanonameserver import Server + _nanonameserver_available = True except ImportError: _nanonameserver_available = False + class Server(object): pass + # Look for systemd-resolved, as it does dangling CNAME responses incorrectly. # # Currently we simply check if the nameserver is 127.0.0.53. _systemd_resolved_present = False try: _resolver = dns.resolver.Resolver() - if _resolver.nameservers == ['127.0.0.53']: + if _resolver.nameservers == ["127.0.0.53"]: _systemd_resolved_present = True except Exception: pass -resolv_conf = u""" +resolv_conf = """ /t/t # comment 1 ; comment 2 @@ -220,19 +223,18 @@ class FakeTime: class BaseResolverTests(unittest.TestCase): - def testRead(self): f = StringIO(resolv_conf) r = dns.resolver.Resolver(configure=False) r.read_resolv_conf(f) - self.assertEqual(r.nameservers, ['10.0.0.1', '10.0.0.2']) - self.assertEqual(r.domain, dns.name.from_text('foo')) + self.assertEqual(r.nameservers, ["10.0.0.1", "10.0.0.2"]) + self.assertEqual(r.domain, dns.name.from_text("foo")) def testReadOptions(self): f = StringIO(resolv_conf_options1) r = dns.resolver.Resolver(configure=False) r.read_resolv_conf(f) - self.assertEqual(r.nameservers, ['10.0.0.1', '10.0.0.2']) + self.assertEqual(r.nameservers, ["10.0.0.1", "10.0.0.2"]) self.assertTrue(r.rotate) self.assertEqual(r.timeout, 1) self.assertEqual(r.ndots, 2) @@ -275,140 +277,147 @@ class BaseResolverTests(unittest.TestCase): f = StringIO(unknown_and_bad_directives) r = dns.resolver.Resolver(configure=False) r.read_resolv_conf(f) - self.assertEqual(r.nameservers, ['10.0.0.1']) + self.assertEqual(r.nameservers, ["10.0.0.1"]) def testReadUnknownOption(self): # The real test here is ignoring the unknown option f = StringIO(unknown_option) r = dns.resolver.Resolver(configure=False) r.read_resolv_conf(f) - self.assertEqual(r.nameservers, ['10.0.0.1']) + self.assertEqual(r.nameservers, ["10.0.0.1"]) def testCacheExpiration(self): with FakeTime() as fake_time: message = dns.message.from_text(message_text) - name = dns.name.from_text('example.') - answer = dns.resolver.Answer(name, dns.rdatatype.A, - dns.rdataclass.IN, message) + name = dns.name.from_text("example.") + answer = dns.resolver.Answer( + name, dns.rdatatype.A, dns.rdataclass.IN, message + ) cache = dns.resolver.Cache() cache.put((name, dns.rdatatype.A, dns.rdataclass.IN), answer) fake_time.sleep(2) - self.assertTrue(cache.get((name, dns.rdatatype.A, - dns.rdataclass.IN)) - is None) + self.assertTrue( + cache.get((name, dns.rdatatype.A, dns.rdataclass.IN)) is None + ) def testCacheCleaning(self): with FakeTime() as fake_time: message = dns.message.from_text(message_text) - name = dns.name.from_text('example.') - answer = dns.resolver.Answer(name, dns.rdatatype.A, - dns.rdataclass.IN, message) + name = dns.name.from_text("example.") + answer = dns.resolver.Answer( + name, dns.rdatatype.A, dns.rdataclass.IN, message + ) cache = dns.resolver.Cache(cleaning_interval=1.0) cache.put((name, dns.rdatatype.A, dns.rdataclass.IN), answer) fake_time.sleep(2) cache._maybe_clean() - self.assertTrue(cache.data.get((name, dns.rdatatype.A, - dns.rdataclass.IN)) - is None) + self.assertTrue( + cache.data.get((name, dns.rdatatype.A, dns.rdataclass.IN)) is None + ) def testCacheNonCleaning(self): with FakeTime() as fake_time: message = dns.message.from_text(message_text) - name = dns.name.from_text('example.') - answer = dns.resolver.Answer(name, dns.rdatatype.A, - dns.rdataclass.IN, message) + name = dns.name.from_text("example.") + answer = dns.resolver.Answer( + name, dns.rdatatype.A, dns.rdataclass.IN, message + ) # override TTL as we're testing non-cleaning answer.expiration = fake_time.time() + 100 cache = dns.resolver.Cache(cleaning_interval=1.0) cache.put((name, dns.rdatatype.A, dns.rdataclass.IN), answer) fake_time.sleep(1.1) - self.assertEqual(cache.get((name, dns.rdatatype.A, - dns.rdataclass.IN)), answer) + self.assertEqual( + cache.get((name, dns.rdatatype.A, dns.rdataclass.IN)), answer + ) def testIndexErrorOnEmptyRRsetAccess(self): def bad(): message = dns.message.from_text(message_text_mx) - name = dns.name.from_text('example.') - answer = dns.resolver.Answer(name, dns.rdatatype.MX, - dns.rdataclass.IN, message) + name = dns.name.from_text("example.") + answer = dns.resolver.Answer( + name, dns.rdatatype.MX, dns.rdataclass.IN, message + ) return answer[0] + self.assertRaises(IndexError, bad) def testIndexErrorOnEmptyRRsetDelete(self): def bad(): message = dns.message.from_text(message_text_mx) - name = dns.name.from_text('example.') - answer = dns.resolver.Answer(name, dns.rdatatype.MX, - dns.rdataclass.IN, message) + name = dns.name.from_text("example.") + answer = dns.resolver.Answer( + name, dns.rdatatype.MX, dns.rdataclass.IN, message + ) del answer[0] + self.assertRaises(IndexError, bad) def testRRsetDelete(self): message = dns.message.from_text(message_text) - name = dns.name.from_text('example.') - answer = dns.resolver.Answer(name, dns.rdatatype.A, - dns.rdataclass.IN, message) + name = dns.name.from_text("example.") + answer = dns.resolver.Answer(name, dns.rdatatype.A, dns.rdataclass.IN, message) del answer[0] self.assertEqual(len(answer), 0) def testLRUReplace(self): cache = dns.resolver.LRUCache(4) for i in range(0, 5): - name = dns.name.from_text('example%d.' % i) + name = dns.name.from_text("example%d." % i) answer = FakeAnswer(time.time() + 1) cache.put((name, dns.rdatatype.A, dns.rdataclass.IN), answer) for i in range(0, 5): - name = dns.name.from_text('example%d.' % i) + name = dns.name.from_text("example%d." % i) if i == 0: - self.assertTrue(cache.get((name, dns.rdatatype.A, - dns.rdataclass.IN)) - is None) + self.assertTrue( + cache.get((name, dns.rdatatype.A, dns.rdataclass.IN)) is None + ) else: - self.assertTrue(not cache.get((name, dns.rdatatype.A, - dns.rdataclass.IN)) - is None) + self.assertTrue( + not cache.get((name, dns.rdatatype.A, dns.rdataclass.IN)) is None + ) def testLRUDoesLRU(self): cache = dns.resolver.LRUCache(4) for i in range(0, 4): - name = dns.name.from_text('example%d.' % i) + name = dns.name.from_text("example%d." % i) answer = FakeAnswer(time.time() + 1) cache.put((name, dns.rdatatype.A, dns.rdataclass.IN), answer) - name = dns.name.from_text('example0.') + name = dns.name.from_text("example0.") cache.get((name, dns.rdatatype.A, dns.rdataclass.IN)) # The LRU is now example1. - name = dns.name.from_text('example4.') + name = dns.name.from_text("example4.") answer = FakeAnswer(time.time() + 1) cache.put((name, dns.rdatatype.A, dns.rdataclass.IN), answer) for i in range(0, 5): - name = dns.name.from_text('example%d.' % i) + name = dns.name.from_text("example%d." % i) if i == 1: - self.assertTrue(cache.get((name, dns.rdatatype.A, - dns.rdataclass.IN)) - is None) + self.assertTrue( + cache.get((name, dns.rdatatype.A, dns.rdataclass.IN)) is None + ) else: - self.assertTrue(not cache.get((name, dns.rdatatype.A, - dns.rdataclass.IN)) - is None) + self.assertTrue( + not cache.get((name, dns.rdatatype.A, dns.rdataclass.IN)) is None + ) def testLRUExpiration(self): with FakeTime() as fake_time: cache = dns.resolver.LRUCache(4) for i in range(0, 4): - name = dns.name.from_text('example%d.' % i) + name = dns.name.from_text("example%d." % i) answer = FakeAnswer(time.time() + 1) cache.put((name, dns.rdatatype.A, dns.rdataclass.IN), answer) fake_time.sleep(2) for i in range(0, 4): - name = dns.name.from_text('example%d.' % i) - self.assertTrue(cache.get((name, dns.rdatatype.A, - dns.rdataclass.IN)) - is None) + name = dns.name.from_text("example%d." % i) + self.assertTrue( + cache.get((name, dns.rdatatype.A, dns.rdataclass.IN)) is None + ) def test_cache_flush(self): - name1 = dns.name.from_text('name1') - name2 = dns.name.from_text('name2') - name3 = dns.name.from_text('name3') + name1 = dns.name.from_text("name1") + name2 = dns.name.from_text("name2") + name3 = dns.name.from_text("name3") basic_cache = dns.resolver.Cache() lru_cache = dns.resolver.LRUCache(100) for cache in [basic_cache, lru_cache]: @@ -453,10 +462,11 @@ class BaseResolverTests(unittest.TestCase): return True cnode = cnode.next return False + cache = dns.resolver.LRUCache(4) answer1 = FakeAnswer(time.time() + 10) answer2 = FakeAnswer(time.time() + 10) - key = (dns.name.from_text('key.'), dns.rdatatype.A, dns.rdataclass.IN) + key = (dns.name.from_text("key."), dns.rdatatype.A, dns.rdataclass.IN) cache.put(key, answer1) canswer = cache.get(key) self.assertTrue(canswer is answer1) @@ -469,8 +479,8 @@ class BaseResolverTests(unittest.TestCase): def test_cache_stats(self): caches = [dns.resolver.Cache(), dns.resolver.LRUCache(4)] - key1 = (dns.name.from_text('key1.'), dns.rdatatype.A, dns.rdataclass.IN) - key2 = (dns.name.from_text('key2.'), dns.rdatatype.A, dns.rdataclass.IN) + key1 = (dns.name.from_text("key1."), dns.rdatatype.A, dns.rdataclass.IN) + key2 = (dns.name.from_text("key2."), dns.rdatatype.A, dns.rdataclass.IN) for cache in caches: answer1 = FakeAnswer(time.time() + 10) answer2 = FakeAnswer(10) # expired! @@ -507,66 +517,83 @@ class BaseResolverTests(unittest.TestCase): # with an empty answer section. Other than that it doesn't # apply. message = dns.message.from_text(dangling_cname_0_message_text) - name = dns.name.from_text('example.') - answer = dns.resolver.Answer(name, dns.rdatatype.A, dns.rdataclass.IN, - message) + name = dns.name.from_text("example.") + answer = dns.resolver.Answer(name, dns.rdatatype.A, dns.rdataclass.IN, message) + def test_python_internal_truth(answer): if answer: return True else: return False + self.assertFalse(test_python_internal_truth(answer)) for a in answer: pass def testSearchListsRelative(self): res = dns.resolver.Resolver(configure=False) - res.domain = dns.name.from_text('example') - res.search = [dns.name.from_text(x) for x in - ['dnspython.org', 'dnspython.net']] - qname = dns.name.from_text('www', None) + res.domain = dns.name.from_text("example") + res.search = [dns.name.from_text(x) for x in ["dnspython.org", "dnspython.net"]] + qname = dns.name.from_text("www", None) qnames = res._get_qnames_to_try(qname, True) - self.assertEqual(qnames, - [dns.name.from_text(x) for x in - ['www.dnspython.org', 'www.dnspython.net', 'www.']]) + self.assertEqual( + qnames, + [ + dns.name.from_text(x) + for x in ["www.dnspython.org", "www.dnspython.net", "www."] + ], + ) qnames = res._get_qnames_to_try(qname, False) - self.assertEqual(qnames, - [dns.name.from_text('www.')]) + self.assertEqual(qnames, [dns.name.from_text("www.")]) qnames = res._get_qnames_to_try(qname, None) - self.assertEqual(qnames, - [dns.name.from_text('www.')]) + self.assertEqual(qnames, [dns.name.from_text("www.")]) # # Now change search default on resolver to True # res.use_search_by_default = True qnames = res._get_qnames_to_try(qname, None) - self.assertEqual(qnames, - [dns.name.from_text(x) for x in - ['www.dnspython.org', 'www.dnspython.net', 'www.']]) + self.assertEqual( + qnames, + [ + dns.name.from_text(x) + for x in ["www.dnspython.org", "www.dnspython.net", "www."] + ], + ) # # Now test ndots # - qname = dns.name.from_text('a.b', None) + qname = dns.name.from_text("a.b", None) res.ndots = 1 qnames = res._get_qnames_to_try(qname, True) - self.assertEqual(qnames, - [dns.name.from_text(x) for x in - ['a.b', 'a.b.dnspython.org', 'a.b.dnspython.net']]) + self.assertEqual( + qnames, + [ + dns.name.from_text(x) + for x in ["a.b", "a.b.dnspython.org", "a.b.dnspython.net"] + ], + ) res.ndots = 2 qnames = res._get_qnames_to_try(qname, True) - self.assertEqual(qnames, - [dns.name.from_text(x) for x in - ['a.b.dnspython.org', 'a.b.dnspython.net', 'a.b']]) - qname = dns.name.from_text('a.b.c', None) + self.assertEqual( + qnames, + [ + dns.name.from_text(x) + for x in ["a.b.dnspython.org", "a.b.dnspython.net", "a.b"] + ], + ) + qname = dns.name.from_text("a.b.c", None) qnames = res._get_qnames_to_try(qname, True) - self.assertEqual(qnames, - [dns.name.from_text(x) for x in - ['a.b.c', 'a.b.c.dnspython.org', - 'a.b.c.dnspython.net']]) + self.assertEqual( + qnames, + [ + dns.name.from_text(x) + for x in ["a.b.c", "a.b.c.dnspython.org", "a.b.c.dnspython.net"] + ], + ) def testSearchListsAbsolute(self): res = dns.resolver.Resolver(configure=False) - qname = dns.name.from_text('absolute') + qname = dns.name.from_text("absolute") qnames = res._get_qnames_to_try(qname, True) self.assertEqual(qnames, [qname]) qnames = res._get_qnames_to_try(qname, False) @@ -590,91 +617,94 @@ class BaseResolverTests(unittest.TestCase): self.assertEqual(r.flags, flags) def testUseTSIG(self): - keyring = dns.tsigkeyring.from_text( - { - 'keyname.': 'NjHwPsMKjdN++dOfE5iAiQ==' - } - ) + keyring = dns.tsigkeyring.from_text({"keyname.": "NjHwPsMKjdN++dOfE5iAiQ=="}) r = dns.resolver.Resolver(configure=False) r.use_tsig(keyring) self.assertEqual(r.keyring, keyring) self.assertEqual(r.keyname, None) self.assertEqual(r.keyalgorithm, dns.tsig.default_algorithm) -keyname = dns.name.from_text('keyname') +keyname = dns.name.from_text("keyname") @unittest.skipIf(not _network_available, "Internet not reachable") class LiveResolverTests(unittest.TestCase): def testZoneForName1(self): - name = dns.name.from_text('www.dnspython.org.') - ezname = dns.name.from_text('dnspython.org.') + 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) def testZoneForName2(self): - name = dns.name.from_text('a.b.www.dnspython.org.') - ezname = dns.name.from_text('dnspython.org.') + 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) def testZoneForName3(self): - ezname = dns.name.from_text('dnspython.org.') - zname = dns.resolver.zone_for_name('dnspython.org.') + ezname = dns.name.from_text("dnspython.org.") + zname = dns.resolver.zone_for_name("dnspython.org.") self.assertEqual(zname, ezname) def testZoneForName4(self): def bad(): - name = dns.name.from_text('dnspython.org', None) + name = dns.name.from_text("dnspython.org", None) dns.resolver.zone_for_name(name) + self.assertRaises(dns.resolver.NotAbsolute, bad) def testResolve(self): - answer = dns.resolver.resolve('dns.google.', 'A') + 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) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) def testResolveTCP(self): - answer = dns.resolver.resolve('dns.google.', 'A', tcp=True) + 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) + self.assertTrue("8.8.8.8" in seen) + self.assertTrue("8.8.4.4" in seen) def testResolveAddress(self): - answer = dns.resolver.resolve_address('8.8.8.8') - dnsgoogle = dns.name.from_text('dns.google.') + answer = dns.resolver.resolve_address("8.8.8.8") + dnsgoogle = dns.name.from_text("dns.google.") self.assertEqual(answer[0].target, dnsgoogle) - @patch.object(dns.message.Message, 'use_edns') + @patch.object(dns.message.Message, "use_edns") def testResolveEdnsOptions(self, message_use_edns_mock): resolver = dns.resolver.Resolver() - options = [dns.edns.ECSOption('1.1.1.1')] + options = [dns.edns.ECSOption("1.1.1.1")] resolver.use_edns(True, options=options) - resolver.resolve('dns.google.', 'A') - assert {'options': options} in message_use_edns_mock.call_args + resolver.resolve("dns.google.", "A") + assert {"options": options} in message_use_edns_mock.call_args def testResolveNodataException(self): def bad(): - dns.resolver.resolve('dnspython.org.', 'SRV') + dns.resolver.resolve("dnspython.org.", "SRV") + self.assertRaises(dns.resolver.NoAnswer, bad) def testResolveNodataAnswer(self): - qname = dns.name.from_text('dnspython.org') - qclass = dns.rdataclass.from_text('IN') - qtype = dns.rdatatype.from_text('SRV') + qname = dns.name.from_text("dnspython.org") + qclass = dns.rdataclass.from_text("IN") + qtype = dns.rdatatype.from_text("SRV") answer = dns.resolver.resolve(qname, qtype, raise_on_no_answer=False) - self.assertRaises(KeyError, - lambda: answer.response.find_rrset(answer.response.answer, - qname, qclass, qtype)) + self.assertRaises( + KeyError, + lambda: answer.response.find_rrset( + answer.response.answer, qname, qclass, qtype + ), + ) def testResolveNXDOMAIN(self): - qname = dns.name.from_text('nxdomain.dnspython.org') - qclass = dns.rdataclass.from_text('IN') - qtype = dns.rdatatype.from_text('A') + qname = dns.name.from_text("nxdomain.dnspython.org") + qclass = dns.rdataclass.from_text("IN") + qtype = dns.rdatatype.from_text("A") + def bad(): answer = dns.resolver.resolve(qname, qtype) + try: dns.resolver.resolve(qname, qtype) self.assertTrue(False) # should not happen! @@ -684,36 +714,36 @@ class LiveResolverTests(unittest.TestCase): def testResolveCacheHit(self): res = dns.resolver.Resolver(configure=False) - res.nameservers = ['8.8.8.8'] + res.nameservers = ["8.8.8.8"] res.cache = dns.resolver.Cache() - answer1 = res.resolve('dns.google.', 'A') + answer1 = res.resolve("dns.google.", "A") seen = set([rdata.address for rdata in answer1]) - self.assertIn('8.8.8.8', seen) - self.assertIn('8.8.4.4', seen) - answer2 = res.resolve('dns.google.', 'A') + self.assertIn("8.8.8.8", seen) + self.assertIn("8.8.4.4", seen) + answer2 = res.resolve("dns.google.", "A") self.assertIs(answer2, answer1) def testCanonicalNameNoCNAME(self): - cname = dns.name.from_text('www.google.com') - self.assertEqual(dns.resolver.canonical_name('www.google.com'), cname) + cname = dns.name.from_text("www.google.com") + self.assertEqual(dns.resolver.canonical_name("www.google.com"), cname) def testCanonicalNameCNAME(self): - name = dns.name.from_text('www.dnspython.org') - cname = dns.name.from_text('dmfrjf4ips8xa.cloudfront.net') + name = dns.name.from_text("www.dnspython.org") + cname = dns.name.from_text("dmfrjf4ips8xa.cloudfront.net") self.assertEqual(dns.resolver.canonical_name(name), cname) @unittest.skipIf(_systemd_resolved_present, "systemd-resolved in use") def testCanonicalNameDangling(self): - name = dns.name.from_text('dangling-cname.dnspython.org') - cname = dns.name.from_text('dangling-target.dnspython.org') + name = dns.name.from_text("dangling-cname.dnspython.org") + cname = dns.name.from_text("dangling-target.dnspython.org") self.assertEqual(dns.resolver.canonical_name(name), cname) def testNameserverSetting(self): res = dns.resolver.Resolver(configure=False) - ns = ['1.2.3.4', '::1', 'https://ns.example'] + ns = ["1.2.3.4", "::1", "https://ns.example"] res.nameservers = ns[:] self.assertEqual(res.nameservers, ns) - for ns in ['999.999.999.999', 'ns.example.', 'bogus://ns.example']: + for ns in ["999.999.999.999", "ns.example.", "bogus://ns.example"]: with self.assertRaises(ValueError): res.nameservers = [ns] @@ -731,13 +761,18 @@ class PollingMonkeyPatchMixin(object): unittest.TestCase.tearDown(self) -class SelectResolverTestCase(PollingMonkeyPatchMixin, LiveResolverTests, unittest.TestCase): +class SelectResolverTestCase( + PollingMonkeyPatchMixin, LiveResolverTests, unittest.TestCase +): def selector_class(self): return selectors.SelectSelector -if hasattr(selectors, 'PollSelector'): - class PollResolverTestCase(PollingMonkeyPatchMixin, LiveResolverTests, unittest.TestCase): +if hasattr(selectors, "PollSelector"): + + class PollResolverTestCase( + PollingMonkeyPatchMixin, LiveResolverTests, unittest.TestCase + ): def selector_class(self): return selectors.PollSelector @@ -747,35 +782,35 @@ class NXDOMAINExceptionTestCase(unittest.TestCase): # pylint: disable=broad-except def test_nxdomain_compatible(self): - n1 = dns.name.Name(('a', 'b', '')) - n2 = dns.name.Name(('a', 'b', 's', '')) + n1 = dns.name.Name(("a", "b", "")) + n2 = dns.name.Name(("a", "b", "s", "")) try: raise dns.resolver.NXDOMAIN except dns.exception.DNSException as e: self.assertEqual(e.args, (e.__doc__,)) - self.assertTrue(('kwargs' in dir(e))) + self.assertTrue(("kwargs" in dir(e))) self.assertEqual(str(e), e.__doc__, str(e)) - self.assertTrue(('qnames' not in e.kwargs)) - self.assertTrue(('responses' not in e.kwargs)) + self.assertTrue(("qnames" not in e.kwargs)) + self.assertTrue(("responses" not in e.kwargs)) try: raise dns.resolver.NXDOMAIN("errmsg") except dns.exception.DNSException as e: self.assertEqual(e.args, ("errmsg",)) - self.assertTrue(('kwargs' in dir(e))) + self.assertTrue(("kwargs" in dir(e))) self.assertEqual(str(e), "errmsg", str(e)) - self.assertTrue(('qnames' not in e.kwargs)) - self.assertTrue(('responses' not in e.kwargs)) + self.assertTrue(("qnames" not in e.kwargs)) + self.assertTrue(("responses" not in e.kwargs)) try: raise dns.resolver.NXDOMAIN("errmsg", -1) except dns.exception.DNSException as e: self.assertEqual(e.args, ("errmsg", -1)) - self.assertTrue(('kwargs' in dir(e))) + self.assertTrue(("kwargs" in dir(e))) self.assertEqual(str(e), "('errmsg', -1)", str(e)) - self.assertTrue(('qnames' not in e.kwargs)) - self.assertTrue(('responses' not in e.kwargs)) + self.assertTrue(("qnames" not in e.kwargs)) + self.assertTrue(("responses" not in e.kwargs)) try: raise dns.resolver.NXDOMAIN(qnames=None) @@ -797,12 +832,12 @@ class NXDOMAINExceptionTestCase(unittest.TestCase): except dns.exception.DNSException as e: MSG = "The DNS query name does not exist: a.b." self.assertEqual(e.args, (MSG,), repr(e.args)) - self.assertTrue(('kwargs' in dir(e))) + self.assertTrue(("kwargs" in dir(e))) self.assertEqual(str(e), MSG, str(e)) - self.assertTrue(('qnames' in e.kwargs)) - self.assertEqual(e.kwargs['qnames'], [n1]) - self.assertTrue(('responses' in e.kwargs)) - self.assertEqual(e.kwargs['responses'], {}) + self.assertTrue(("qnames" in e.kwargs)) + self.assertEqual(e.kwargs["qnames"], [n1]) + self.assertTrue(("responses" in e.kwargs)) + self.assertEqual(e.kwargs["responses"], {}) try: raise dns.resolver.NXDOMAIN(qnames=[n2, n1]) @@ -811,50 +846,49 @@ class NXDOMAINExceptionTestCase(unittest.TestCase): e = e0 + e MSG = "None of DNS query names exist: a.b.s., a.b." self.assertEqual(e.args, (MSG,), repr(e.args)) - self.assertTrue(('kwargs' in dir(e))) + self.assertTrue(("kwargs" in dir(e))) self.assertEqual(str(e), MSG, str(e)) - self.assertTrue(('qnames' in e.kwargs)) - self.assertEqual(e.kwargs['qnames'], [n2, n1]) - self.assertTrue(('responses' in e.kwargs)) - self.assertEqual(e.kwargs['responses'], {}) + self.assertTrue(("qnames" in e.kwargs)) + self.assertEqual(e.kwargs["qnames"], [n2, n1]) + self.assertTrue(("responses" in e.kwargs)) + self.assertEqual(e.kwargs["responses"], {}) try: - raise dns.resolver.NXDOMAIN(qnames=[n1], responses=['r1.1']) + raise dns.resolver.NXDOMAIN(qnames=[n1], responses=["r1.1"]) except Exception as e: self.assertTrue((isinstance(e, AttributeError))) try: - raise dns.resolver.NXDOMAIN(qnames=[n1], responses={n1: 'r1.1'}) + raise dns.resolver.NXDOMAIN(qnames=[n1], responses={n1: "r1.1"}) except dns.resolver.NXDOMAIN as e: MSG = "The DNS query name does not exist: a.b." self.assertEqual(e.args, (MSG,), repr(e.args)) - self.assertTrue(('kwargs' in dir(e))) + self.assertTrue(("kwargs" in dir(e))) self.assertEqual(str(e), MSG, str(e)) - self.assertTrue(('qnames' in e.kwargs)) - self.assertEqual(e.kwargs['qnames'], [n1]) - self.assertTrue(('responses' in e.kwargs)) - self.assertEqual(e.kwargs['responses'], {n1: 'r1.1'}) + self.assertTrue(("qnames" in e.kwargs)) + self.assertEqual(e.kwargs["qnames"], [n1]) + self.assertTrue(("responses" in e.kwargs)) + self.assertEqual(e.kwargs["responses"], {n1: "r1.1"}) def test_nxdomain_merge(self): - n1 = dns.name.Name(('a', 'b', '')) - n2 = dns.name.Name(('a', 'b', '')) - n3 = dns.name.Name(('a', 'b', 'c', '')) - n4 = dns.name.Name(('a', 'b', 'd', '')) - responses1 = {n1: 'r1.1', n2: 'r1.2', n4: 'r1.4'} - qnames1 = [n1, n4] # n2 == n1 - responses2 = {n2: 'r2.2', n3: 'r2.3'} + n1 = dns.name.Name(("a", "b", "")) + n2 = dns.name.Name(("a", "b", "")) + n3 = dns.name.Name(("a", "b", "c", "")) + n4 = dns.name.Name(("a", "b", "d", "")) + responses1 = {n1: "r1.1", n2: "r1.2", n4: "r1.4"} + qnames1 = [n1, n4] # n2 == n1 + responses2 = {n2: "r2.2", n3: "r2.3"} qnames2 = [n2, n3] e0 = dns.resolver.NXDOMAIN() e1 = dns.resolver.NXDOMAIN(qnames=qnames1, responses=responses1) e2 = dns.resolver.NXDOMAIN(qnames=qnames2, responses=responses2) e = e1 + e0 + e2 self.assertRaises(AttributeError, lambda: e0 + e0) - self.assertEqual(e.kwargs['qnames'], [n1, n4, n3], - repr(e.kwargs['qnames'])) - self.assertTrue(e.kwargs['responses'][n1].startswith('r2.')) - self.assertTrue(e.kwargs['responses'][n2].startswith('r2.')) - self.assertTrue(e.kwargs['responses'][n3].startswith('r2.')) - self.assertTrue(e.kwargs['responses'][n4].startswith('r1.')) + self.assertEqual(e.kwargs["qnames"], [n1, n4, n3], repr(e.kwargs["qnames"])) + self.assertTrue(e.kwargs["responses"][n1].startswith("r2.")) + self.assertTrue(e.kwargs["responses"][n2].startswith("r2.")) + self.assertTrue(e.kwargs["responses"][n3].startswith("r2.")) + self.assertTrue(e.kwargs["responses"][n4].startswith("r1.")) def test_nxdomain_canonical_name(self): cname1 = "91.11.8-22.17.172.in-addr.arpa." @@ -877,35 +911,39 @@ class NXDOMAINExceptionTestCase(unittest.TestCase): class ResolverMiscTestCase(unittest.TestCase): - if sys.platform != 'win32': + if sys.platform != "win32": + def test_read_nonexistent_config(self): res = dns.resolver.Resolver(configure=False) - pathname = '/etc/nonexistent-resolv.conf' - self.assertRaises(dns.resolver.NoResolverConfiguration, - lambda: res.read_resolv_conf(pathname)) + pathname = "/etc/nonexistent-resolv.conf" + self.assertRaises( + dns.resolver.NoResolverConfiguration, + lambda: res.read_resolv_conf(pathname), + ) def test_compute_timeout(self): res = dns.resolver.Resolver(configure=False) now = time.time() - self.assertRaises(dns.resolver.Timeout, - lambda: res._compute_timeout(now + 10000)) - self.assertRaises(dns.resolver.Timeout, - lambda: res._compute_timeout(0)) + self.assertRaises( + dns.resolver.Timeout, lambda: res._compute_timeout(now + 10000) + ) + self.assertRaises(dns.resolver.Timeout, lambda: res._compute_timeout(0)) # not raising is the test res._compute_timeout(now + 0.5) - if sys.platform == 'win32': + if sys.platform == "win32": + def test_configure_win32_domain(self): - n = dns.name.from_text('home.') - self.assertEqual(n, dns.win32util._config_domain('home')) - self.assertEqual(n, dns.win32util._config_domain('.home')) + n = dns.name.from_text("home.") + self.assertEqual(n, dns.win32util._config_domain("home")) + self.assertEqual(n, dns.win32util._config_domain(".home")) class ResolverNameserverValidTypeTestCase(unittest.TestCase): def test_set_nameservers_to_list(self): resolver = dns.resolver.Resolver(configure=False) - resolver.nameservers = ['1.2.3.4'] - self.assertEqual(resolver.nameservers, ['1.2.3.4']) + resolver.nameservers = ["1.2.3.4"] + self.assertEqual(resolver.nameservers, ["1.2.3.4"]) def test_set_namservers_to_empty_list(self): resolver = dns.resolver.Resolver(configure=False) @@ -914,27 +952,35 @@ class ResolverNameserverValidTypeTestCase(unittest.TestCase): def test_set_nameservers_invalid_type(self): resolver = dns.resolver.Resolver(configure=False) - invalid_nameservers = [None, '1.2.3.4', 1234, (1, 2, 3, 4), {'invalid': 'nameserver'}] + invalid_nameservers = [ + None, + "1.2.3.4", + 1234, + (1, 2, 3, 4), + {"invalid": "nameserver"}, + ] for invalid_nameserver in invalid_nameservers: with self.assertRaises(ValueError): resolver.nameservers = invalid_nameserver class NaptrNanoNameserver(Server): - def handle(self, request): response = dns.message.make_response(request.message) response.set_rcode(dns.rcode.REFUSED) response.flags |= dns.flags.RA try: - zero_subdomain = dns.e164.from_e164('0') + zero_subdomain = dns.e164.from_e164("0") if request.qname.is_subdomain(zero_subdomain): response.set_rcode(dns.rcode.NXDOMAIN) response.flags |= dns.flags.AA - elif request.qtype == dns.rdatatype.NAPTR and \ - request.qclass == dns.rdataclass.IN: - rrs = dns.rrset.from_text(request.qname, 300, 'IN', 'NAPTR', - '0 0 "" "" "" .') + elif ( + request.qtype == dns.rdatatype.NAPTR + and request.qclass == dns.rdataclass.IN + ): + rrs = dns.rrset.from_text( + request.qname, 300, "IN", "NAPTR", '0 0 "" "" "" .' + ) response.answer.append(rrs) response.set_rcode(dns.rcode.NOERROR) response.flags |= dns.flags.AA @@ -943,28 +989,28 @@ class NaptrNanoNameserver(Server): return response -@unittest.skipIf(not (_network_available and _nanonameserver_available), - "Internet and NanoAuth required") +@unittest.skipIf( + not (_network_available and _nanonameserver_available), + "Internet and NanoAuth required", +) class NanoTests(unittest.TestCase): - def testE164Query(self): with NaptrNanoNameserver() as na: res = dns.resolver.Resolver(configure=False) res.port = na.udp_address[1] res.nameservers = [na.udp_address[0]] - answer = dns.e164.query('1650551212', ['e164.arpa'], res) + answer = dns.e164.query("1650551212", ["e164.arpa"], res) self.assertEqual(answer[0].order, 0) self.assertEqual(answer[0].preference, 0) - self.assertEqual(answer[0].flags, b'') - self.assertEqual(answer[0].service, b'') - self.assertEqual(answer[0].regexp, b'') + self.assertEqual(answer[0].flags, b"") + self.assertEqual(answer[0].service, b"") + self.assertEqual(answer[0].regexp, b"") self.assertEqual(answer[0].replacement, dns.name.root) with self.assertRaises(dns.resolver.NXDOMAIN): - dns.e164.query('0123456789', ['e164.arpa'], res) + dns.e164.query("0123456789", ["e164.arpa"], res) class AlwaysType3NXDOMAINNanoNameserver(Server): - def handle(self, request): response = dns.message.make_response(request.message) response.set_rcode(dns.rcode.NXDOMAIN) @@ -973,56 +1019,65 @@ class AlwaysType3NXDOMAINNanoNameserver(Server): class AlwaysNXDOMAINNanoNameserver(Server): - def handle(self, request): response = dns.message.make_response(request.message) response.set_rcode(dns.rcode.NXDOMAIN) response.flags |= dns.flags.RA - origin = dns.name.from_text('example.') - soa_rrset = response.find_rrset(response.authority, origin, - dns.rdataclass.IN, dns.rdatatype.SOA, - create=True) - rdata = dns.rdata.from_text('IN', 'SOA', - 'ns.example. root.example. 1 2 3 4 5') + origin = dns.name.from_text("example.") + soa_rrset = response.find_rrset( + response.authority, + origin, + dns.rdataclass.IN, + dns.rdatatype.SOA, + create=True, + ) + rdata = dns.rdata.from_text("IN", "SOA", "ns.example. root.example. 1 2 3 4 5") soa_rrset.add(rdata) soa_rrset.update_ttl(300) return response -class AlwaysNoErrorNoDataNanoNameserver(Server): +class AlwaysNoErrorNoDataNanoNameserver(Server): def handle(self, request): response = dns.message.make_response(request.message) response.set_rcode(dns.rcode.NOERROR) response.flags |= dns.flags.RA - origin = dns.name.from_text('example.') - soa_rrset = response.find_rrset(response.authority, origin, - dns.rdataclass.IN, dns.rdatatype.SOA, - create=True) - rdata = dns.rdata.from_text('IN', 'SOA', - 'ns.example. root.example. 1 2 3 4 5') + origin = dns.name.from_text("example.") + soa_rrset = response.find_rrset( + response.authority, + origin, + dns.rdataclass.IN, + dns.rdatatype.SOA, + create=True, + ) + rdata = dns.rdata.from_text("IN", "SOA", "ns.example. root.example. 1 2 3 4 5") soa_rrset.add(rdata) soa_rrset.update_ttl(300) return response -@unittest.skipIf(not (_network_available and _nanonameserver_available), - "Internet and NanoAuth required") -class ZoneForNameTests(unittest.TestCase): + +@unittest.skipIf( + not (_network_available and _nanonameserver_available), + "Internet and NanoAuth required", +) +class ZoneForNameTests(unittest.TestCase): def testNoRootSOA(self): with AlwaysType3NXDOMAINNanoNameserver() as na: res = dns.resolver.Resolver(configure=False) res.port = na.udp_address[1] res.nameservers = [na.udp_address[0]] with self.assertRaises(dns.resolver.NoRootSOA): - dns.resolver.zone_for_name('www.foo.bar.', resolver=res) + dns.resolver.zone_for_name("www.foo.bar.", resolver=res) def testHelpfulNXDOMAIN(self): with AlwaysNXDOMAINNanoNameserver() as na: res = dns.resolver.Resolver(configure=False) res.port = na.udp_address[1] res.nameservers = [na.udp_address[0]] - expected = dns.name.from_text('example.') - name = dns.resolver.zone_for_name('1.2.3.4.5.6.7.8.9.10.example.', - resolver=res) + expected = dns.name.from_text("example.") + name = dns.resolver.zone_for_name( + "1.2.3.4.5.6.7.8.9.10.example.", resolver=res + ) self.assertEqual(name, expected) def testHelpfulNoErrorNoData(self): @@ -1030,19 +1085,19 @@ class ZoneForNameTests(unittest.TestCase): res = dns.resolver.Resolver(configure=False) res.port = na.udp_address[1] res.nameservers = [na.udp_address[0]] - expected = dns.name.from_text('example.') - name = dns.resolver.zone_for_name('1.2.3.4.5.6.7.8.9.10.example.', - resolver=res) + expected = dns.name.from_text("example.") + name = dns.resolver.zone_for_name( + "1.2.3.4.5.6.7.8.9.10.example.", resolver=res + ) self.assertEqual(name, expected) -class DroppingNanoNameserver(Server): +class DroppingNanoNameserver(Server): def handle(self, request): return None class FormErrNanoNameserver(Server): - def handle(self, request): r = dns.message.make_response(request.message) r.set_rcode(dns.rcode.FORMERR) @@ -1052,8 +1107,11 @@ class FormErrNanoNameserver(Server): # we use pytest for these so we can have a "slow" mark later if we want to # (right now it's still fast enough we don't really need it) -@pytest.mark.skipif(not (_network_available and _nanonameserver_available), - reason="Internet and NanoAuth required") + +@pytest.mark.skipif( + not (_network_available and _nanonameserver_available), + reason="Internet and NanoAuth required", +) def testResolverTimeout(): with DroppingNanoNameserver() as na: res = dns.resolver.Resolver(configure=False) @@ -1062,13 +1120,13 @@ def testResolverTimeout(): res.timeout = 0.2 try: lifetime = 1.0 - a = res.resolve('www.dnspython.org', lifetime=lifetime) + a = res.resolve("www.dnspython.org", lifetime=lifetime) assert False # should never happen except dns.resolver.LifetimeTimeout as e: - assert e.kwargs['timeout'] >= lifetime + assert e.kwargs["timeout"] >= lifetime # The length of errors can vary based on how slow things are, # but it ought to be > 1, so we assert that. - errors = e.kwargs['errors'] + errors = e.kwargs["errors"] assert len(errors) > 1 for error in errors: assert error[0] == na.udp_address[0] # address @@ -1076,28 +1134,30 @@ def testResolverTimeout(): assert error[2] == na.udp_address[1] # port assert isinstance(error[3], dns.exception.Timeout) # exception -@pytest.mark.skipif(not (_network_available and _nanonameserver_available), - reason="Internet and NanoAuth required") + +@pytest.mark.skipif( + not (_network_available and _nanonameserver_available), + reason="Internet and NanoAuth required", +) def testResolverNoNameservers(): with FormErrNanoNameserver() as na: res = dns.resolver.Resolver(configure=False) res.port = na.udp_address[1] res.nameservers = [na.udp_address[0]] try: - a = res.resolve('www.dnspython.org') + a = res.resolve("www.dnspython.org") assert False # should never happen except dns.resolver.NoNameservers as e: - errors = e.kwargs['errors'] + errors = e.kwargs["errors"] assert len(errors) == 1 for error in errors: assert error[0] == na.udp_address[0] # address assert not error[1] # not TCP assert error[2] == na.udp_address[1] # port - assert error[3] == 'FORMERR' + assert error[3] == "FORMERR" class SlowAlwaysType3NXDOMAINNanoNameserver(Server): - def handle(self, request): response = dns.message.make_response(request.message) response.set_rcode(dns.rcode.NXDOMAIN) @@ -1106,13 +1166,16 @@ class SlowAlwaysType3NXDOMAINNanoNameserver(Server): return response -@pytest.mark.skipif(not (_network_available and _nanonameserver_available), - reason="Internet and NanoAuth required") +@pytest.mark.skipif( + not (_network_available and _nanonameserver_available), + reason="Internet and NanoAuth required", +) def testZoneForNameLifetimeTimeout(): with SlowAlwaysType3NXDOMAINNanoNameserver() as na: res = dns.resolver.Resolver(configure=False) res.port = na.udp_address[1] res.nameservers = [na.udp_address[0]] with pytest.raises(dns.resolver.LifetimeTimeout): - dns.resolver.zone_for_name('1.2.3.4.5.6.7.8.9.10.example.', - resolver=res, lifetime=1.0) + dns.resolver.zone_for_name( + "1.2.3.4.5.6.7.8.9.10.example.", resolver=res, lifetime=1.0 + ) diff --git a/tests/test_resolver_override.py b/tests/test_resolver_override.py index ac93316..3d79445 100644 --- a/tests/test_resolver_override.py +++ b/tests/test_resolver_override.py @@ -13,17 +13,16 @@ import dns.resolver # skip those if it's not there. _network_available = True try: - socket.gethostbyname('dnspython.org') + socket.gethostbyname("dnspython.org") except socket.gaierror: _network_available = False @unittest.skipIf(not _network_available, "Internet not reachable") class OverrideSystemResolverTestCase(unittest.TestCase): - def setUp(self): self.res = dns.resolver.Resolver(configure=False) - self.res.nameservers = ['8.8.8.8'] + self.res.nameservers = ["8.8.8.8"] self.res.cache = dns.resolver.LRUCache() dns.resolver.override_system_resolver(self.res) @@ -32,34 +31,50 @@ class OverrideSystemResolverTestCase(unittest.TestCase): self.res = None def test_override(self): - self.assertTrue(socket.getaddrinfo is - dns.resolver._getaddrinfo) - socket.gethostbyname('www.dnspython.org') - answer = self.res.cache.get((dns.name.from_text('www.dnspython.org.'), - dns.rdatatype.A, dns.rdataclass.IN)) + self.assertTrue(socket.getaddrinfo is dns.resolver._getaddrinfo) + socket.gethostbyname("www.dnspython.org") + answer = self.res.cache.get( + ( + dns.name.from_text("www.dnspython.org."), + dns.rdatatype.A, + dns.rdataclass.IN, + ) + ) self.assertTrue(answer is not None) self.res.cache.flush() - socket.gethostbyname_ex('www.dnspython.org') - answer = self.res.cache.get((dns.name.from_text('www.dnspython.org.'), - dns.rdatatype.A, dns.rdataclass.IN)) + socket.gethostbyname_ex("www.dnspython.org") + answer = self.res.cache.get( + ( + dns.name.from_text("www.dnspython.org."), + dns.rdatatype.A, + dns.rdataclass.IN, + ) + ) self.assertTrue(answer is not None) self.res.cache.flush() - socket.getfqdn('8.8.8.8') + socket.getfqdn("8.8.8.8") answer = self.res.cache.get( - (dns.name.from_text('8.8.8.8.in-addr.arpa.'), - dns.rdatatype.PTR, dns.rdataclass.IN)) + ( + dns.name.from_text("8.8.8.8.in-addr.arpa."), + dns.rdatatype.PTR, + dns.rdataclass.IN, + ) + ) self.assertTrue(answer is not None) self.res.cache.flush() - socket.gethostbyaddr('8.8.8.8') + socket.gethostbyaddr("8.8.8.8") answer = self.res.cache.get( - (dns.name.from_text('8.8.8.8.in-addr.arpa.'), - dns.rdatatype.PTR, dns.rdataclass.IN)) + ( + dns.name.from_text("8.8.8.8.in-addr.arpa."), + dns.rdatatype.PTR, + dns.rdataclass.IN, + ) + ) self.assertTrue(answer is not None) # restoring twice is harmless, so we restore now instead of # waiting for tearDown so we can assert that it worked dns.resolver.restore_system_resolver() - self.assertTrue(socket.getaddrinfo is - dns.resolver._original_getaddrinfo) + self.assertTrue(socket.getaddrinfo is dns.resolver._original_getaddrinfo) def equivalent_info(self, a, b): if len(a) != len(b): @@ -70,7 +85,7 @@ class OverrideSystemResolverTestCase(unittest.TestCase): # looking for a zero protocol. y = (x[0], x[1], 0, x[3], x[4]) if y not in b: - print('NOT EQUIVALENT') + print("NOT EQUIVALENT") print(a) print(b) return False @@ -81,93 +96,114 @@ class OverrideSystemResolverTestCase(unittest.TestCase): b = dns.resolver._original_getaddrinfo(*args, **kwargs) return self.equivalent_info(a, b) - @unittest.skipIf(sys.platform == 'win32', - 'avoid windows original getaddrinfo issues') + @unittest.skipIf( + sys.platform == "win32", "avoid windows original getaddrinfo issues" + ) def test_basic_getaddrinfo(self): - self.assertTrue(self.equivalent('dns.google', 53, socket.AF_INET, - socket.SOCK_DGRAM)) - self.assertTrue(self.equivalent('dns.google', 53, socket.AF_INET6, - socket.SOCK_DGRAM)) - self.assertTrue(self.equivalent('dns.google', None, socket.AF_UNSPEC, - socket.SOCK_DGRAM)) - self.assertTrue(self.equivalent('8.8.8.8', 53, socket.AF_INET, - socket.SOCK_DGRAM)) - self.assertTrue(self.equivalent('2001:4860:4860::8888', 53, - socket.AF_INET6, socket.SOCK_DGRAM)) - self.assertTrue(self.equivalent('8.8.8.8', 53, socket.AF_INET, - socket.SOCK_DGRAM, - flags=socket.AI_NUMERICHOST)) - self.assertTrue(self.equivalent('2001:4860:4860::8888', 53, - socket.AF_INET6, socket.SOCK_DGRAM, - flags=socket.AI_NUMERICHOST)) + self.assertTrue( + self.equivalent("dns.google", 53, socket.AF_INET, socket.SOCK_DGRAM) + ) + self.assertTrue( + self.equivalent("dns.google", 53, socket.AF_INET6, socket.SOCK_DGRAM) + ) + self.assertTrue( + self.equivalent("dns.google", None, socket.AF_UNSPEC, socket.SOCK_DGRAM) + ) + self.assertTrue( + self.equivalent("8.8.8.8", 53, socket.AF_INET, socket.SOCK_DGRAM) + ) + self.assertTrue( + self.equivalent( + "2001:4860:4860::8888", 53, socket.AF_INET6, socket.SOCK_DGRAM + ) + ) + self.assertTrue( + self.equivalent( + "8.8.8.8", + 53, + socket.AF_INET, + socket.SOCK_DGRAM, + flags=socket.AI_NUMERICHOST, + ) + ) + self.assertTrue( + self.equivalent( + "2001:4860:4860::8888", + 53, + socket.AF_INET6, + socket.SOCK_DGRAM, + flags=socket.AI_NUMERICHOST, + ) + ) def test_getaddrinfo_nxdomain(self): try: - socket.getaddrinfo('nxdomain.dnspython.org.', 53) - self.assertTrue(False) # should not happen! + socket.getaddrinfo("nxdomain.dnspython.org.", 53) + self.assertTrue(False) # should not happen! except socket.gaierror as e: self.assertEqual(e.errno, socket.EAI_NONAME) def test_getaddrinfo_service(self): - a = socket.getaddrinfo('dns.google', 'domain') - b = socket.getaddrinfo('dns.google', 53) + a = socket.getaddrinfo("dns.google", "domain") + b = socket.getaddrinfo("dns.google", 53) self.assertTrue(self.equivalent_info(a, b)) try: - socket.getaddrinfo('dns.google', 'domain', - flags=socket.AI_NUMERICSERV) - self.assertTrue(False) # should not happen! + socket.getaddrinfo("dns.google", "domain", flags=socket.AI_NUMERICSERV) + self.assertTrue(False) # should not happen! except socket.gaierror as e: self.assertEqual(e.errno, socket.EAI_NONAME) def test_getaddrinfo_only_service(self): - infos = socket.getaddrinfo(service=53, family=socket.AF_INET, - socktype=socket.SOCK_DGRAM, - proto=socket.IPPROTO_UDP) + infos = socket.getaddrinfo( + service=53, + family=socket.AF_INET, + socktype=socket.SOCK_DGRAM, + proto=socket.IPPROTO_UDP, + ) self.assertEqual(len(infos), 1) info = infos[0] self.assertEqual(info[0], socket.AF_INET) self.assertEqual(info[1], socket.SOCK_DGRAM) self.assertEqual(info[2], socket.IPPROTO_UDP) - self.assertEqual(info[4], ('127.0.0.1', 53)) + self.assertEqual(info[4], ("127.0.0.1", 53)) def test_unknown_service_fails(self): with self.assertRaises(socket.gaierror): - socket.getaddrinfo('dns.google.', 'bogus-service') + socket.getaddrinfo("dns.google.", "bogus-service") def test_getnameinfo_tcp(self): - info = socket.getnameinfo(('8.8.8.8', 53)) - self.assertEqual(info, ('dns.google', 'domain')) + info = socket.getnameinfo(("8.8.8.8", 53)) + self.assertEqual(info, ("dns.google", "domain")) def test_getnameinfo_udp(self): - info = socket.getnameinfo(('8.8.8.8', 53), socket.NI_DGRAM) - self.assertEqual(info, ('dns.google', 'domain')) - - -# Give up on testing this for now as all of the names I've considered -# using for testing are part of CDNs and there is deep magic in -# gethostbyaddr() that python's getfqdn() is using. At any rate, -# the problem is that dnspython just gives up whereas the native python -# code is looking up www.dnspython.org, picking a CDN IPv4 address -# (sometimes) and returning the reverse lookup of that address (i.e. -# the domain name of the CDN server). This isn't what I'd consider the -# FQDN of www.dnspython.org to be! -# -# def test_getfqdn(self): -# b = socket.getfqdn('www.dnspython.org') -# # we do this now because python's original getfqdn calls -# # gethostbyaddr() and we don't want it to call us! -# dns.resolver.restore_system_resolver() -# a = dns.resolver._original_getfqdn('www.dnspython.org') -# self.assertEqual(dns.name.from_text(a), dns.name.from_text(b)) + info = socket.getnameinfo(("8.8.8.8", 53), socket.NI_DGRAM) + self.assertEqual(info, ("dns.google", "domain")) + + # Give up on testing this for now as all of the names I've considered + # using for testing are part of CDNs and there is deep magic in + # gethostbyaddr() that python's getfqdn() is using. At any rate, + # the problem is that dnspython just gives up whereas the native python + # code is looking up www.dnspython.org, picking a CDN IPv4 address + # (sometimes) and returning the reverse lookup of that address (i.e. + # the domain name of the CDN server). This isn't what I'd consider the + # FQDN of www.dnspython.org to be! + # + # def test_getfqdn(self): + # b = socket.getfqdn('www.dnspython.org') + # # we do this now because python's original getfqdn calls + # # gethostbyaddr() and we don't want it to call us! + # dns.resolver.restore_system_resolver() + # a = dns.resolver._original_getfqdn('www.dnspython.org') + # self.assertEqual(dns.name.from_text(a), dns.name.from_text(b)) def test_gethostbyaddr(self): - a = dns.resolver._original_gethostbyaddr('8.8.8.8') - b = socket.gethostbyaddr('8.8.8.8') + a = dns.resolver._original_gethostbyaddr("8.8.8.8") + b = socket.gethostbyaddr("8.8.8.8") # We only test elements 0 and 2 as we don't set aliases currently! self.assertEqual(a[0], b[0]) self.assertEqual(a[2], b[2]) - a = dns.resolver._original_gethostbyaddr('2001:4860:4860::8888') - b = socket.gethostbyaddr('2001:4860:4860::8888') + a = dns.resolver._original_gethostbyaddr("2001:4860:4860::8888") + b = socket.gethostbyaddr("2001:4860:4860::8888") self.assertEqual(a[0], b[0]) self.assertEqual(a[2], b[2]) @@ -178,7 +214,6 @@ class FakeResolver: class OverrideSystemResolverUsingFakeResolverTestCase(unittest.TestCase): - def setUp(self): self.res = FakeResolver() dns.resolver.override_system_resolver(self.res) @@ -189,7 +224,7 @@ class OverrideSystemResolverUsingFakeResolverTestCase(unittest.TestCase): def test_temporary_failure(self): with self.assertRaises(socket.gaierror): - socket.getaddrinfo('dns.google') + socket.getaddrinfo("dns.google") # We don't need the fake resolver for the following tests, but we # don't need the live network either, so we're testing here. @@ -200,16 +235,15 @@ class OverrideSystemResolverUsingFakeResolverTestCase(unittest.TestCase): def test_AI_ADDRCONFIG_fails(self): with self.assertRaises(socket.gaierror): - socket.getaddrinfo('dns.google', flags=socket.AI_ADDRCONFIG) + socket.getaddrinfo("dns.google", flags=socket.AI_ADDRCONFIG) def test_gethostbyaddr_of_name_fails(self): with self.assertRaises(socket.gaierror): - socket.gethostbyaddr('bogus') + socket.gethostbyaddr("bogus") @unittest.skipIf(not _network_available, "Internet not reachable") class OverrideSystemResolverUsingDefaultResolverTestCase(unittest.TestCase): - def setUp(self): self.res = FakeResolver() dns.resolver.override_system_resolver() diff --git a/tests/test_rrset.py b/tests/test_rrset.py index 5c3f17d..23e33bb 100644 --- a/tests/test_rrset.py +++ b/tests/test_rrset.py @@ -21,142 +21,174 @@ import unittest import dns.name import dns.rrset -class RRsetTestCase(unittest.TestCase): +class RRsetTestCase(unittest.TestCase): def testEqual1(self): - r1 = dns.rrset.from_text('foo', 300, 'in', 'a', '10.0.0.1', '10.0.0.2') - r2 = dns.rrset.from_text('FOO', 300, 'in', 'a', '10.0.0.2', '10.0.0.1') + r1 = dns.rrset.from_text("foo", 300, "in", "a", "10.0.0.1", "10.0.0.2") + r2 = dns.rrset.from_text("FOO", 300, "in", "a", "10.0.0.2", "10.0.0.1") self.assertEqual(r1, r2) def testEqual2(self): - r1 = dns.rrset.from_text('foo', 300, 'in', 'a', '10.0.0.1', '10.0.0.2') - r2 = dns.rrset.from_text('FOO', 600, 'in', 'a', '10.0.0.2', '10.0.0.1') + r1 = dns.rrset.from_text("foo", 300, "in", "a", "10.0.0.1", "10.0.0.2") + r2 = dns.rrset.from_text("FOO", 600, "in", "a", "10.0.0.2", "10.0.0.1") self.assertEqual(r1, r2) def testNotEqual1(self): - r1 = dns.rrset.from_text('fooa', 30, 'in', 'a', '10.0.0.1', '10.0.0.2') - r2 = dns.rrset.from_text('FOO', 30, 'in', 'a', '10.0.0.2', '10.0.0.1') + r1 = dns.rrset.from_text("fooa", 30, "in", "a", "10.0.0.1", "10.0.0.2") + r2 = dns.rrset.from_text("FOO", 30, "in", "a", "10.0.0.2", "10.0.0.1") self.assertNotEqual(r1, r2) def testNotEqual2(self): - r1 = dns.rrset.from_text('foo', 30, 'in', 'a', '10.0.0.1', '10.0.0.3') - r2 = dns.rrset.from_text('FOO', 30, 'in', 'a', '10.0.0.2', '10.0.0.1') + r1 = dns.rrset.from_text("foo", 30, "in", "a", "10.0.0.1", "10.0.0.3") + r2 = dns.rrset.from_text("FOO", 30, "in", "a", "10.0.0.2", "10.0.0.1") self.assertNotEqual(r1, r2) def testNotEqual3(self): - r1 = dns.rrset.from_text('foo', 30, 'in', 'a', '10.0.0.1', '10.0.0.2', - '10.0.0.3') - r2 = dns.rrset.from_text('FOO', 30, 'in', 'a', '10.0.0.2', '10.0.0.1') + r1 = dns.rrset.from_text( + "foo", 30, "in", "a", "10.0.0.1", "10.0.0.2", "10.0.0.3" + ) + r2 = dns.rrset.from_text("FOO", 30, "in", "a", "10.0.0.2", "10.0.0.1") self.assertNotEqual(r1, r2) def testNotEqual4(self): - r1 = dns.rrset.from_text('foo', 30, 'in', 'a', '10.0.0.1') - r2 = dns.rrset.from_text('FOO', 30, 'in', 'a', '10.0.0.2', '10.0.0.1') + r1 = dns.rrset.from_text("foo", 30, "in", "a", "10.0.0.1") + r2 = dns.rrset.from_text("FOO", 30, "in", "a", "10.0.0.2", "10.0.0.1") self.assertNotEqual(r1, r2) def testCodec2003(self): - r1 = dns.rrset.from_text_list('Königsgäßchen', 30, 'in', 'ns', - ['Königsgäßchen']) - r2 = dns.rrset.from_text_list('xn--knigsgsschen-lcb0w', 30, 'in', 'ns', - ['xn--knigsgsschen-lcb0w']) + r1 = dns.rrset.from_text_list( + "Königsgäßchen", 30, "in", "ns", ["Königsgäßchen"] + ) + r2 = dns.rrset.from_text_list( + "xn--knigsgsschen-lcb0w", 30, "in", "ns", ["xn--knigsgsschen-lcb0w"] + ) self.assertEqual(r1, r2) - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def testCodec2008(self): - r1 = dns.rrset.from_text_list('Königsgäßchen', 30, 'in', 'ns', - ['Königsgäßchen'], - idna_codec=dns.name.IDNA_2008) - r2 = dns.rrset.from_text_list('xn--knigsgchen-b4a3dun', 30, 'in', 'ns', - ['xn--knigsgchen-b4a3dun'], - idna_codec=dns.name.IDNA_2008) + r1 = dns.rrset.from_text_list( + "Königsgäßchen", + 30, + "in", + "ns", + ["Königsgäßchen"], + idna_codec=dns.name.IDNA_2008, + ) + r2 = dns.rrset.from_text_list( + "xn--knigsgchen-b4a3dun", + 30, + "in", + "ns", + ["xn--knigsgchen-b4a3dun"], + idna_codec=dns.name.IDNA_2008, + ) self.assertEqual(r1, r2) def testCopy(self): - r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a', - ['10.0.0.1', '10.0.0.2']) + r1 = dns.rrset.from_text_list("foo", 30, "in", "a", ["10.0.0.1", "10.0.0.2"]) r2 = r1.copy() self.assertFalse(r1 is r2) self.assertTrue(r1 == r2) def testFullMatch1(self): - r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a', - ['10.0.0.1', '10.0.0.2']) - self.assertTrue(r1.full_match(r1.name, dns.rdataclass.IN, - dns.rdatatype.A, dns.rdatatype.NONE)) + r1 = dns.rrset.from_text_list("foo", 30, "in", "a", ["10.0.0.1", "10.0.0.2"]) + self.assertTrue( + r1.full_match( + r1.name, dns.rdataclass.IN, dns.rdatatype.A, dns.rdatatype.NONE + ) + ) def testFullMatch2(self): - r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a', - ['10.0.0.1', '10.0.0.2']) + r1 = dns.rrset.from_text_list("foo", 30, "in", "a", ["10.0.0.1", "10.0.0.2"]) r1.deleting = dns.rdataclass.NONE - self.assertTrue(r1.full_match(r1.name, dns.rdataclass.IN, - dns.rdatatype.A, dns.rdatatype.NONE, - dns.rdataclass.NONE)) + self.assertTrue( + r1.full_match( + r1.name, + dns.rdataclass.IN, + dns.rdatatype.A, + dns.rdatatype.NONE, + dns.rdataclass.NONE, + ) + ) def testNoFullMatch1(self): - n = dns.name.from_text('bar', None) - r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a', - ['10.0.0.1', '10.0.0.2']) - self.assertFalse(r1.full_match(n, dns.rdataclass.IN, - dns.rdatatype.A, dns.rdatatype.NONE, - dns.rdataclass.ANY)) + n = dns.name.from_text("bar", None) + r1 = dns.rrset.from_text_list("foo", 30, "in", "a", ["10.0.0.1", "10.0.0.2"]) + self.assertFalse( + r1.full_match( + n, + dns.rdataclass.IN, + dns.rdatatype.A, + dns.rdatatype.NONE, + dns.rdataclass.ANY, + ) + ) def testNoFullMatch2(self): - r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a', - ['10.0.0.1', '10.0.0.2']) + r1 = dns.rrset.from_text_list("foo", 30, "in", "a", ["10.0.0.1", "10.0.0.2"]) r1.deleting = dns.rdataclass.NONE - self.assertFalse(r1.full_match(r1.name, dns.rdataclass.IN, - dns.rdatatype.A, dns.rdatatype.NONE, - dns.rdataclass.ANY)) + self.assertFalse( + r1.full_match( + r1.name, + dns.rdataclass.IN, + dns.rdatatype.A, + dns.rdatatype.NONE, + dns.rdataclass.ANY, + ) + ) def testNoFullMatch3(self): - r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a', - ['10.0.0.1', '10.0.0.2']) - self.assertFalse(r1.full_match(r1.name, dns.rdataclass.IN, - dns.rdatatype.MX, dns.rdatatype.NONE, - dns.rdataclass.ANY)) + r1 = dns.rrset.from_text_list("foo", 30, "in", "a", ["10.0.0.1", "10.0.0.2"]) + self.assertFalse( + r1.full_match( + r1.name, + dns.rdataclass.IN, + dns.rdatatype.MX, + dns.rdatatype.NONE, + dns.rdataclass.ANY, + ) + ) def testMatchCompatibilityWithFullMatch(self): - r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a', - ['10.0.0.1', '10.0.0.2']) - self.assertTrue(r1.match(r1.name, dns.rdataclass.IN, - dns.rdatatype.A, dns.rdatatype.NONE)) + r1 = dns.rrset.from_text_list("foo", 30, "in", "a", ["10.0.0.1", "10.0.0.2"]) + self.assertTrue( + r1.match(r1.name, dns.rdataclass.IN, dns.rdatatype.A, dns.rdatatype.NONE) + ) def testMatchCompatibilityWithRdatasetMatch(self): - r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a', - ['10.0.0.1', '10.0.0.2']) - self.assertTrue(r1.match(dns.rdataclass.IN, dns.rdatatype.A, - dns.rdatatype.NONE)) + r1 = dns.rrset.from_text_list("foo", 30, "in", "a", ["10.0.0.1", "10.0.0.2"]) + self.assertTrue( + r1.match(dns.rdataclass.IN, dns.rdatatype.A, dns.rdatatype.NONE) + ) def testToRdataset(self): - r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a', - ['10.0.0.1', '10.0.0.2']) - r2 = dns.rdataset.from_text_list('in', 'a', 30, - ['10.0.0.1', '10.0.0.2']) + r1 = dns.rrset.from_text_list("foo", 30, "in", "a", ["10.0.0.1", "10.0.0.2"]) + r2 = dns.rdataset.from_text_list("in", "a", 30, ["10.0.0.1", "10.0.0.2"]) self.assertEqual(r1.to_rdataset(), r2) def testFromRdata(self): - rdata1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1') - rdata2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2') - expected_rrs = dns.rrset.from_text('foo', 300, 'in', 'a', '10.0.0.1', - '10.0.0.2') - rrs = dns.rrset.from_rdata('foo', 300, rdata1, rdata2) + rdata1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1") + rdata2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2") + expected_rrs = dns.rrset.from_text( + "foo", 300, "in", "a", "10.0.0.1", "10.0.0.2" + ) + rrs = dns.rrset.from_rdata("foo", 300, rdata1, rdata2) self.assertEqual(rrs, expected_rrs) def testEmptyList(self): def bad(): - rrs = dns.rrset.from_rdata_list('foo', 300, []) + rrs = dns.rrset.from_rdata_list("foo", 300, []) + self.assertRaises(ValueError, bad) def testTTLMinimization(self): - rrs = dns.rrset.RRset(dns.name.from_text('foo'), - dns.rdataclass.IN, dns.rdatatype.A) - rdata1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1') - rdata2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2') + rrs = dns.rrset.RRset( + dns.name.from_text("foo"), dns.rdataclass.IN, dns.rdatatype.A + ) + rdata1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1") + rdata2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2") rrs.add(rdata1, 300) self.assertEqual(rrs.ttl, 300) rrs.add(rdata2, 30) @@ -166,26 +198,33 @@ class RRsetTestCase(unittest.TestCase): self.assertEqual(rrs.ttl, 3) def testNotEqualOtherType(self): - rrs = dns.rrset.RRset(dns.name.from_text('foo'), - dns.rdataclass.IN, dns.rdatatype.A) + rrs = dns.rrset.RRset( + dns.name.from_text("foo"), dns.rdataclass.IN, dns.rdatatype.A + ) self.assertFalse(rrs == 123) def testRepr(self): - rrset = dns.rrset.from_text('foo', 30, 'in', 'a', '10.0.0.1', - '10.0.0.2') - self.assertEqual(repr(rrset), - '<DNS foo IN A RRset: [<10.0.0.1>, <10.0.0.2>]>') + rrset = dns.rrset.from_text("foo", 30, "in", "a", "10.0.0.1", "10.0.0.2") + self.assertEqual(repr(rrset), "<DNS foo IN A RRset: [<10.0.0.1>, <10.0.0.2>]>") rrset.deleting = dns.rdataclass.NONE - self.assertEqual(repr(rrset), - '<DNS foo IN A delete=NONE RRset: ' + - '[<10.0.0.1>, <10.0.0.2>]>') + self.assertEqual( + repr(rrset), + "<DNS foo IN A delete=NONE RRset: " + "[<10.0.0.1>, <10.0.0.2>]>", + ) rrset = dns.rrset.from_text( - 'foo', 30, 'in', 'rrsig', - 'A 1 3 3600 20200701000000 20200601000000 1 NAME Ym9ndXM=') - self.assertEqual(repr(rrset), - '<DNS foo IN RRSIG(A) RRset: ' + - '[<A 1 3 3600 20200701000000 20200601000000 ' + - '1 NAME Ym9ndXM=>]>') - -if __name__ == '__main__': + "foo", + 30, + "in", + "rrsig", + "A 1 3 3600 20200701000000 20200601000000 1 NAME Ym9ndXM=", + ) + self.assertEqual( + repr(rrset), + "<DNS foo IN RRSIG(A) RRset: " + + "[<A 1 3 3600 20200701000000 20200601000000 " + + "1 NAME Ym9ndXM=>]>", + ) + + +if __name__ == "__main__": unittest.main() diff --git a/tests/test_rrset_reader.py b/tests/test_rrset_reader.py index 8d4255e..3ae942e 100644 --- a/tests/test_rrset_reader.py +++ b/tests/test_rrset_reader.py @@ -3,17 +3,17 @@ import pytest import dns.rrset from dns.zonefile import read_rrsets -expected_mx_1= dns.rrset.from_text('name.', 300, 'in', 'mx', '10 a.', '20 b.') -expected_mx_2 = dns.rrset.from_text('name.', 10, 'in', 'mx', '10 a.', '20 b.') -expected_mx_3 = dns.rrset.from_text('foo.', 10, 'in', 'mx', '10 a.') -expected_mx_4 = dns.rrset.from_text('bar.', 10, 'in', 'mx', '20 b.') -expected_mx_5 = dns.rrset.from_text('foo.example.', 10, 'in', 'mx', - '10 a.example.') -expected_mx_6 = dns.rrset.from_text('bar.example.', 10, 'in', 'mx', '20 b.') -expected_mx_7 = dns.rrset.from_text('foo', 10, 'in', 'mx', '10 a') -expected_mx_8 = dns.rrset.from_text('bar', 10, 'in', 'mx', '20 b.') -expected_ns_1 = dns.rrset.from_text('name.', 300, 'in', 'ns', 'hi.') -expected_ns_2 = dns.rrset.from_text('name.', 300, 'ch', 'ns', 'hi.') +expected_mx_1 = dns.rrset.from_text("name.", 300, "in", "mx", "10 a.", "20 b.") +expected_mx_2 = dns.rrset.from_text("name.", 10, "in", "mx", "10 a.", "20 b.") +expected_mx_3 = dns.rrset.from_text("foo.", 10, "in", "mx", "10 a.") +expected_mx_4 = dns.rrset.from_text("bar.", 10, "in", "mx", "20 b.") +expected_mx_5 = dns.rrset.from_text("foo.example.", 10, "in", "mx", "10 a.example.") +expected_mx_6 = dns.rrset.from_text("bar.example.", 10, "in", "mx", "20 b.") +expected_mx_7 = dns.rrset.from_text("foo", 10, "in", "mx", "10 a") +expected_mx_8 = dns.rrset.from_text("bar", 10, "in", "mx", "20 b.") +expected_ns_1 = dns.rrset.from_text("name.", 300, "in", "ns", "hi.") +expected_ns_2 = dns.rrset.from_text("name.", 300, "ch", "ns", "hi.") + def equal_rrsets(a, b): # return True iff. a and b have the same rrsets regardless of order @@ -24,108 +24,119 @@ def equal_rrsets(a, b): return False return True + def test_name_ttl_rdclass_forced(): - input='''; + input = """; mx 10 a mx 20 b. -ns hi''' - rrsets = read_rrsets(input, name='name', ttl=300) +ns hi""" + rrsets = read_rrsets(input, name="name", ttl=300) assert equal_rrsets(rrsets, [expected_mx_1, expected_ns_1]) assert rrsets[0].ttl == 300 assert rrsets[1].ttl == 300 + def test_name_ttl_rdclass_forced_rdata_split(): - input='''; + input = """; mx 10 a ns hi -mx 20 b.''' - rrsets = read_rrsets(input, name='name', ttl=300) +mx 20 b.""" + rrsets = read_rrsets(input, name="name", ttl=300) assert equal_rrsets(rrsets, [expected_mx_1, expected_ns_1]) + def test_name_ttl_rdclass_rdtype_forced(): - input='''; + input = """; 10 a -20 b.''' - rrsets = read_rrsets(input, name='name', ttl=300, rdtype='mx') +20 b.""" + rrsets = read_rrsets(input, name="name", ttl=300, rdtype="mx") assert equal_rrsets(rrsets, [expected_mx_1]) + def test_name_rdclass_forced(): - input = '''30 mx 10 a + input = """30 mx 10 a 10 mx 20 b. -''' - rrsets = read_rrsets(input, name='name') +""" + rrsets = read_rrsets(input, name="name") assert equal_rrsets(rrsets, [expected_mx_2]) assert rrsets[0].ttl == 10 + def test_rdclass_forced(): - input = '''; + input = """; foo 20 mx 10 a bar 30 mx 20 b. -''' +""" rrsets = read_rrsets(input) assert equal_rrsets(rrsets, [expected_mx_3, expected_mx_4]) + def test_rdclass_forced_with_origin(): - input = '''; + input = """; foo 20 mx 10 a bar.example. 30 mx 20 b. -''' - rrsets = read_rrsets(input, origin='example') +""" + rrsets = read_rrsets(input, origin="example") assert equal_rrsets(rrsets, [expected_mx_5, expected_mx_6]) def test_rdclass_forced_with_origin_relativized(): - input = '''; + input = """; foo 20 mx 10 a.example. bar.example. 30 mx 20 b. -''' - rrsets = read_rrsets(input, origin='example', relativize=True) +""" + rrsets = read_rrsets(input, origin="example", relativize=True) assert equal_rrsets(rrsets, [expected_mx_7, expected_mx_8]) + def test_rdclass_matching_default_tolerated(): - input = '''; + input = """; foo 20 mx 10 a.example. bar.example. 30 in mx 20 b. -''' - rrsets = read_rrsets(input, origin='example', relativize=True, - rdclass=None) +""" + rrsets = read_rrsets(input, origin="example", relativize=True, rdclass=None) assert equal_rrsets(rrsets, [expected_mx_7, expected_mx_8]) + def test_rdclass_not_matching_default_rejected(): - input = '''; + input = """; foo 20 mx 10 a.example. bar.example. 30 ch mx 20 b. -''' +""" with pytest.raises(dns.exception.SyntaxError): - rrsets = read_rrsets(input, origin='example', relativize=True, - rdclass=None) + rrsets = read_rrsets(input, origin="example", relativize=True, rdclass=None) + def test_default_rdclass_is_none(): - input = '' + input = "" with pytest.raises(TypeError): - rrsets = read_rrsets(input, default_rdclass=None, origin='example', - relativize=True) + rrsets = read_rrsets( + input, default_rdclass=None, origin="example", relativize=True + ) + def test_name_rdclass_rdtype_force(): # No real-world usage should do this, but it can be specified so we test it. - input = '''; + input = """; 30 10 a 10 20 b. -''' - rrsets = read_rrsets(input, name='name', rdtype='mx') +""" + rrsets = read_rrsets(input, name="name", rdtype="mx") assert equal_rrsets(rrsets, [expected_mx_1]) assert rrsets[0].ttl == 10 + def test_rdclass_rdtype_force(): # No real-world usage should do this, but it can be specified so we test it. - input = '''; + input = """; foo 30 10 a bar 30 20 b. -''' - rrsets = read_rrsets(input, rdtype='mx') +""" + rrsets = read_rrsets(input, rdtype="mx") assert equal_rrsets(rrsets, [expected_mx_3, expected_mx_4]) + # also weird but legal -#input5 = '''foo 30 10 a -#bar 10 20 foo. +# input5 = '''foo 30 10 a +# bar 10 20 foo. #''' diff --git a/tests/test_serial.py b/tests/test_serial.py index a9ef2df..8e6c439 100644 --- a/tests/test_serial.py +++ b/tests/test_serial.py @@ -4,12 +4,15 @@ import unittest import dns.serial + def S2(v): return dns.serial.Serial(v, bits=2) + def S8(v): return dns.serial.Serial(v, bits=8) + class SerialTestCase(unittest.TestCase): def test_rfc_1982_2_bit_cases(self): self.assertEqual(S2(0) + S2(1), S2(1)) @@ -67,13 +70,17 @@ class SerialTestCase(unittest.TestCase): def test_addition_bounds(self): self.assertRaises(ValueError, lambda: S8(0) + 128) self.assertRaises(ValueError, lambda: S8(0) - 128) + def bad1(): v = S8(0) v += 128 + self.assertRaises(ValueError, bad1) + def bad2(): v = S8(0) v -= 128 + self.assertRaises(ValueError, bad2) def test_casting(self): @@ -85,32 +92,36 @@ class SerialTestCase(unittest.TestCase): self.assertTrue(S8(0) >= 255) def test_uncastable(self): - self.assertRaises(ValueError, lambda: S8(0) + 'a') - self.assertRaises(ValueError, lambda: S8(0) - 'a') + self.assertRaises(ValueError, lambda: S8(0) + "a") + self.assertRaises(ValueError, lambda: S8(0) - "a") + def bad1(): v = S8(0) - v += 'a' + v += "a" + self.assertRaises(ValueError, bad1) + def bad2(): v = S8(0) - v -= 'a' + v -= "a" + self.assertRaises(ValueError, bad2) def test_uncomparable(self): self.assertFalse(S8(0) == S2(0)) - self.assertFalse(S8(0) == 'a') - self.assertTrue(S8(0) != 'a') - self.assertRaises(TypeError, lambda: S8(0) < 'a') - self.assertRaises(TypeError, lambda: S8(0) <= 'a') - self.assertRaises(TypeError, lambda: S8(0) > 'a') - self.assertRaises(TypeError, lambda: S8(0) >= 'a') + self.assertFalse(S8(0) == "a") + self.assertTrue(S8(0) != "a") + self.assertRaises(TypeError, lambda: S8(0) < "a") + self.assertRaises(TypeError, lambda: S8(0) <= "a") + self.assertRaises(TypeError, lambda: S8(0) > "a") + self.assertRaises(TypeError, lambda: S8(0) >= "a") def test_modulo(self): self.assertEqual(S8(-1), 255) self.assertEqual(S8(257), 1) def test_repr(self): - self.assertEqual(repr(S8(1)), 'dns.serial.Serial(1, 8)') + self.assertEqual(repr(S8(1)), "dns.serial.Serial(1, 8)") def test_not_equal(self): self.assertNotEqual(S8(0), S8(1)) diff --git a/tests/test_set.py b/tests/test_set.py index 103a6e9..4db97ba 100644 --- a/tests/test_set.py +++ b/tests/test_set.py @@ -23,8 +23,8 @@ import dns.set # for convenience S = dns.set.Set -class SetTestCase(unittest.TestCase): +class SetTestCase(unittest.TestCase): def testLen1(self): s1 = S() self.assertEqual(len(s1), 0) @@ -334,5 +334,6 @@ class SetTestCase(unittest.TestCase): s &= S([1, 2]) self.assertEqual(s, S([1, 2])) -if __name__ == '__main__': + +if __name__ == "__main__": unittest.main() diff --git a/tests/test_svcb.py b/tests/test_svcb.py index 34fc9ad..d2d8dd7 100644 --- a/tests/test_svcb.py +++ b/tests/test_svcb.py @@ -10,18 +10,19 @@ from dns.tokenizer import Tokenizer from tests.util import here + class SVCBTestCase(unittest.TestCase): def check_valid_inputs(self, inputs): expected = inputs[0] for text in inputs: - rr = dns.rdata.from_text('IN', 'SVCB', text) + rr = dns.rdata.from_text("IN", "SVCB", text) new_text = rr.to_text() self.assertEqual(expected, new_text) def check_invalid_inputs(self, inputs): for text in inputs: with self.assertRaises((dns.exception.SyntaxError, ValueError)): - dns.rdata.from_text('IN', 'SVCB', text) + dns.rdata.from_text("IN", "SVCB", text) def test_svcb_general_invalid(self): invalid_inputs = ( @@ -29,19 +30,19 @@ class SVCBTestCase(unittest.TestCase): "1 . alpn=h2 alpn=h3", "1 . alpn=h2 key1=h3", # Quoted keys - "1 . \"alpn=h2\"", + '1 . "alpn=h2"', # Invalid space "1 . alpn= h2", "1 . alpn =h2", "1 . alpn = h2", - "1 . alpn= \"h2\"", + '1 . alpn= "h2"', "1 . =alpn", ) self.check_invalid_inputs(invalid_inputs) def test_svcb_mandatory(self): valid_inputs = ( - "1 . mandatory=\"alpn,no-default-alpn\" alpn=\"h2\" no-default-alpn", + '1 . mandatory="alpn,no-default-alpn" alpn="h2" no-default-alpn', "1 . mandatory=alpn,no-default-alpn alpn=h2 no-default-alpn", "1 . mandatory=key1,key2 alpn=h2 no-default-alpn", "1 . mandatory=alpn,no-default-alpn key1=\\002h2 key2", @@ -81,12 +82,12 @@ class SVCBTestCase(unittest.TestCase): def test_svcb_alpn(self): valid_inputs_two_items = ( - "1 . alpn=\"h2,h3\"", + '1 . alpn="h2,h3"', "1 . alpn=h2,h3", "1 . alpn=h\\050,h3", - "1 . alpn=\"h\\050,h3\"", + '1 . alpn="h\\050,h3"', "1 . alpn=\\h2,h3", - "1 . alpn=\"h2\\,h3\"", + '1 . alpn="h2\\,h3"', "1 . alpn=h2\\,h3", "1 . alpn=h2\\044h3", "1 . key1=\\002h2\\002h3", @@ -94,7 +95,7 @@ class SVCBTestCase(unittest.TestCase): self.check_valid_inputs(valid_inputs_two_items) valid_inputs_one_item = ( - "1 . alpn=\"h2\\\\,h3\"", + '1 . alpn="h2\\\\,h3"', "1 . alpn=h2\\\\,h3", "1 . alpn=h2\\092\\044h3", "1 . key1=\\005h2,h3", @@ -106,13 +107,13 @@ class SVCBTestCase(unittest.TestCase): "1 . alpn=", "1 . alpn=h2,,h3", "1 . alpn=01234567890abcdef01234567890abcdef01234567890abcdef" - "01234567890abcdef01234567890abcdef01234567890abcdef" - "01234567890abcdef01234567890abcdef01234567890abcdef" - "01234567890abcdef01234567890abcdef01234567890abcdef" - "01234567890abcdef01234567890abcdef01234567890abcdef" - "01234567890abcdef", - "1 . alpn=\",h2,h3\"", - "1 . alpn=\"h2,h3,\"", + "01234567890abcdef01234567890abcdef01234567890abcdef" + "01234567890abcdef01234567890abcdef01234567890abcdef" + "01234567890abcdef01234567890abcdef01234567890abcdef" + "01234567890abcdef01234567890abcdef01234567890abcdef" + "01234567890abcdef", + '1 . alpn=",h2,h3"', + '1 . alpn="h2,h3,"', "1 . key1", "1 . key1=", "1 . key1=\\000", @@ -122,18 +123,18 @@ class SVCBTestCase(unittest.TestCase): def test_svcb_no_default_alpn(self): valid_inputs = ( - "1 . alpn=\"h2\" no-default-alpn", - "1 . alpn=\"h2\" no-default-alpn=\"\"", - "1 . alpn=\"h2\" key2", - "1 . alpn=\"h2\" key2=\"\"", + '1 . alpn="h2" no-default-alpn', + '1 . alpn="h2" no-default-alpn=""', + '1 . alpn="h2" key2', + '1 . alpn="h2" key2=""', ) self.check_valid_inputs(valid_inputs) invalid_inputs = ( "1 . no-default-alpn", - "1 . no-default-alpn=\"\"", + '1 . no-default-alpn=""', "1 . key2", - "1 . key2=\"\"", + '1 . key2=""', "1 . alpn=h2 no-default-alpn=foo", "1 . alpn=h2 no-default-alpn=", "1 . alpn=h2 key2=foo", @@ -143,7 +144,7 @@ class SVCBTestCase(unittest.TestCase): def test_svcb_port(self): valid_inputs = ( - "1 . port=\"53\"", + '1 . port="53"', "1 . port=53", "1 . key3=\\000\\053", ) @@ -165,7 +166,7 @@ class SVCBTestCase(unittest.TestCase): def test_svcb_ipv4hint(self): valid_inputs = ( - "1 . ipv4hint=\"0.0.0.0,1.1.1.1\"", + '1 . ipv4hint="0.0.0.0,1.1.1.1"', "1 . ipv4hint=0.0.0.0,1.1.1.1", "1 . key4=\\000\\000\\000\\000\\001\\001\\001\\001", ) @@ -184,7 +185,7 @@ class SVCBTestCase(unittest.TestCase): def test_svcb_ech(self): valid_inputs = ( - "1 . ech=\"Zm9vMA==\"", + '1 . ech="Zm9vMA=="', "1 . ech=Zm9vMA==", "1 . key5=foo0", "1 . key5=\\102\\111\\111\\048", @@ -203,12 +204,12 @@ class SVCBTestCase(unittest.TestCase): def test_svcb_ipv6hint(self): valid_inputs = ( - "1 . ipv6hint=\"::4,1::\"", + '1 . ipv6hint="::4,1::"', "1 . ipv6hint=::4,1::", "1 . key6=\\000\\000\\000\\000\\000\\000\\000\\000" - "\\000\\000\\000\\000\\000\\000\\000\\004" - "\\000\\001\\000\\000\\000\\000\\000\\000" - "\\000\\000\\000\\000\\000\\000\\000\\000", + "\\000\\000\\000\\000\\000\\000\\000\\004" + "\\000\\001\\000\\000\\000\\000\\000\\000" + "\\000\\000\\000\\000\\000\\000\\000\\000", ) self.check_valid_inputs(valid_inputs) @@ -227,17 +228,17 @@ class SVCBTestCase(unittest.TestCase): def test_svcb_unknown(self): valid_inputs_one_key = ( - "1 . key23=\"key45\"", + '1 . key23="key45"', "1 . key23=key45", "1 . key23=key\\052\\053", - "1 . key23=\"key\\052\\053\"", + '1 . key23="key\\052\\053"', "1 . key23=\\107\\101\\121\\052\\053", ) self.check_valid_inputs(valid_inputs_one_key) valid_inputs_one_key_empty = ( "1 . key23", - "1 . key23=\"\"", + '1 . key23=""', ) self.check_valid_inputs(valid_inputs_one_key_empty) @@ -249,24 +250,25 @@ class SVCBTestCase(unittest.TestCase): valid_inputs_two_keys = ( "1 . key24 key48", - "1 . key24=\"\" key48", + '1 . key24="" key48', ) self.check_valid_inputs(valid_inputs_two_keys) def test_svcb_wire(self): valid_inputs = ( - "1 . mandatory=\"alpn,port\" alpn=\"h2\" port=\"257\"", + '1 . mandatory="alpn,port" alpn="h2" port="257"', "\\# 24 0001 00 0000000400010003 00010003026832 000300020101", ) self.check_valid_inputs(valid_inputs) - everything = \ - "100 foo.com. mandatory=\"alpn,port\" alpn=\"h2,h3\" " \ - " no-default-alpn port=\"12345\" ech=\"abcd\" " \ - " ipv4hint=1.2.3.4,4.3.2.1 ipv6hint=1::2,3::4" \ - " key12345=\"foo\"" - rr = dns.rdata.from_text('IN', 'SVCB', everything) - rr2 = dns.rdata.from_text('IN', 'SVCB', rr.to_generic().to_text()) + everything = ( + '100 foo.com. mandatory="alpn,port" alpn="h2,h3" ' + ' no-default-alpn port="12345" ech="abcd" ' + " ipv4hint=1.2.3.4,4.3.2.1 ipv6hint=1::2,3::4" + ' key12345="foo"' + ) + rr = dns.rdata.from_text("IN", "SVCB", everything) + rr2 = dns.rdata.from_text("IN", "SVCB", rr.to_generic().to_text()) self.assertEqual(rr, rr2) invalid_inputs = ( @@ -283,19 +285,19 @@ class SVCBTestCase(unittest.TestCase): self.check_invalid_inputs(invalid_inputs) def test_misc_escape(self): - rdata = dns.rdata.from_text('in', 'svcb', '1 . alpn=\\010\\010') + rdata = dns.rdata.from_text("in", "svcb", "1 . alpn=\\010\\010") expected = '1 . alpn="\\\\010\\\\010"' self.assertEqual(rdata.to_text(), expected) with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'svcb', '1 . alpn=\\0') + dns.rdata.from_text("in", "svcb", "1 . alpn=\\0") with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'svcb', '1 . alpn=\\00') + dns.rdata.from_text("in", "svcb", "1 . alpn=\\00") with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'svcb', '1 . alpn=\\00q') + dns.rdata.from_text("in", "svcb", "1 . alpn=\\00q") with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'svcb', '1 . alpn=\\256') + dns.rdata.from_text("in", "svcb", "1 . alpn=\\256") # This doesn't usually get exercised, so we do it directly. - gp = dns.rdtypes.svcbbase.GenericParam.from_value('\\001\\002') + gp = dns.rdtypes.svcbbase.GenericParam.from_value("\\001\\002") expected = '"\\001\\002"' self.assertEqual(gp.to_text(), expected) @@ -322,8 +324,8 @@ class SVCBTestCase(unittest.TestCase): self.assertTrue(text_token.is_identifier) text_tokenizer.unget(text_token) generic_tokenizer.unget(generic_token) - text_rdata = dns.rdata.from_text('IN', 'SVCB', text_tokenizer) - generic_rdata = dns.rdata.from_text('IN', 'SVCB', generic_tokenizer) + text_rdata = dns.rdata.from_text("IN", "SVCB", text_tokenizer) + generic_rdata = dns.rdata.from_text("IN", "SVCB", generic_tokenizer) self.assertEqual(text_rdata, generic_rdata) def test_svcb_spec_failure_cases(self): @@ -347,43 +349,42 @@ class SVCBTestCase(unittest.TestCase): # mandatory list (Section 7). "1 foo.example.com. mandatory=key123,key123 key123=abc", ) - self.check_invalid_inputs(failure_cases); + self.check_invalid_inputs(failure_cases) def test_alias_mode(self): - rd = dns.rdata.from_text('in', 'svcb', '0 .') + rd = dns.rdata.from_text("in", "svcb", "0 .") self.assertEqual(len(rd.params), 0) self.assertEqual(rd.target, dns.name.root) - self.assertEqual(rd.to_text(), '0 .') - rd = dns.rdata.from_text('in', 'svcb', '0 elsewhere.') - self.assertEqual(rd.target, dns.name.from_text('elsewhere.')) + self.assertEqual(rd.to_text(), "0 .") + rd = dns.rdata.from_text("in", "svcb", "0 elsewhere.") + self.assertEqual(rd.target, dns.name.from_text("elsewhere.")) self.assertEqual(len(rd.params), 0) # provoke 'parameters in AliasMode' from text. with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('in', 'svcb', '0 elsewhere. alpn=h2') + dns.rdata.from_text("in", "svcb", "0 elsewhere. alpn=h2") # provoke 'parameters in AliasMode' from wire too. - wire = bytes.fromhex('0000000000000400010003') + wire = bytes.fromhex("0000000000000400010003") with self.assertRaises(dns.exception.FormError): - dns.rdata.from_wire('in', 'svcb', wire, 0, len(wire)) + dns.rdata.from_wire("in", "svcb", wire, 0, len(wire)) def test_immutability(self): - alpn = dns.rdtypes.svcbbase.ALPNParam.from_value(['h2', 'h3']) + alpn = dns.rdtypes.svcbbase.ALPNParam.from_value(["h2", "h3"]) with self.assertRaises(TypeError): - alpn.ids[0] = 'foo' + alpn.ids[0] = "foo" with self.assertRaises(TypeError): del alpn.ids[0] with self.assertRaises(TypeError): - alpn.ids = 'foo' + alpn.ids = "foo" with self.assertRaises(TypeError): del alpn.ids def test_alias_not_compressed(self): - rrs = dns.rrset.from_text('elsewhere.', 300, 'in', 'svcb', - '0 elseWhere.') + rrs = dns.rrset.from_text("elsewhere.", 300, "in", "svcb", "0 elseWhere.") output = io.BytesIO() compress = {} rrs.to_wire(output, compress) wire = output.getvalue() # Just one of these assertions is enough, but we do both to show # the bug we're checking is fixed. - assert not wire.endswith(b'\xc0\x00') - assert wire.endswith(b'\x09elseWhere\x00') + assert not wire.endswith(b"\xc0\x00") + assert wire.endswith(b"\x09elseWhere\x00") diff --git a/tests/test_tokenizer.py b/tests/test_tokenizer.py index 06f4177..d8b1723 100644 --- a/tests/test_tokenizer.py +++ b/tests/test_tokenizer.py @@ -22,22 +22,22 @@ import dns.tokenizer Token = dns.tokenizer.Token -class TokenizerTestCase(unittest.TestCase): +class TokenizerTestCase(unittest.TestCase): def testStr(self): - tok = dns.tokenizer.Tokenizer('foo') + tok = dns.tokenizer.Tokenizer("foo") token = tok.get() - self.assertEqual(token, Token(dns.tokenizer.IDENTIFIER, 'foo')) + self.assertEqual(token, Token(dns.tokenizer.IDENTIFIER, "foo")) def testQuotedString1(self): tok = dns.tokenizer.Tokenizer(r'"foo"') token = tok.get() - self.assertEqual(token, Token(dns.tokenizer.QUOTED_STRING, 'foo')) + self.assertEqual(token, Token(dns.tokenizer.QUOTED_STRING, "foo")) def testQuotedString2(self): tok = dns.tokenizer.Tokenizer(r'""') token = tok.get() - self.assertEqual(token, Token(dns.tokenizer.QUOTED_STRING, '')) + self.assertEqual(token, Token(dns.tokenizer.QUOTED_STRING, "")) def testQuotedString3(self): tok = dns.tokenizer.Tokenizer(r'"\"foo\""') @@ -47,8 +47,7 @@ class TokenizerTestCase(unittest.TestCase): def testQuotedString4(self): tok = dns.tokenizer.Tokenizer(r'"foo\010bar"') token = tok.get() - self.assertEqual(token, Token(dns.tokenizer.QUOTED_STRING, - 'foo\\010bar')) + self.assertEqual(token, Token(dns.tokenizer.QUOTED_STRING, "foo\\010bar")) def testQuotedString5(self): with self.assertRaises(dns.exception.UnexpectedEnd): @@ -66,223 +65,233 @@ class TokenizerTestCase(unittest.TestCase): tok.get() def testEmpty1(self): - tok = dns.tokenizer.Tokenizer('') + tok = dns.tokenizer.Tokenizer("") token = tok.get() self.assertTrue(token.is_eof()) def testEmpty2(self): - tok = dns.tokenizer.Tokenizer('') + tok = dns.tokenizer.Tokenizer("") token1 = tok.get() token2 = tok.get() self.assertTrue(token1.is_eof() and token2.is_eof()) def testEOL(self): - tok = dns.tokenizer.Tokenizer('\n') + tok = dns.tokenizer.Tokenizer("\n") token1 = tok.get() token2 = tok.get() self.assertTrue(token1.is_eol() and token2.is_eof()) def testWS1(self): - tok = dns.tokenizer.Tokenizer(' \n') + tok = dns.tokenizer.Tokenizer(" \n") token1 = tok.get() self.assertTrue(token1.is_eol()) def testWS2(self): - tok = dns.tokenizer.Tokenizer(' \n') + tok = dns.tokenizer.Tokenizer(" \n") token1 = tok.get(want_leading=True) self.assertTrue(token1.is_whitespace()) def testComment1(self): - tok = dns.tokenizer.Tokenizer(' ;foo\n') + tok = dns.tokenizer.Tokenizer(" ;foo\n") token1 = tok.get() self.assertTrue(token1.is_eol()) def testComment2(self): - tok = dns.tokenizer.Tokenizer(' ;foo\n') + tok = dns.tokenizer.Tokenizer(" ;foo\n") token1 = tok.get(want_comment=True) token2 = tok.get() - self.assertEqual(token1, Token(dns.tokenizer.COMMENT, 'foo')) + self.assertEqual(token1, Token(dns.tokenizer.COMMENT, "foo")) self.assertTrue(token2.is_eol()) def testComment3(self): - tok = dns.tokenizer.Tokenizer(' ;foo bar\n') + tok = dns.tokenizer.Tokenizer(" ;foo bar\n") token1 = tok.get(want_comment=True) token2 = tok.get() - self.assertEqual(token1, Token(dns.tokenizer.COMMENT, 'foo bar')) + self.assertEqual(token1, Token(dns.tokenizer.COMMENT, "foo bar")) self.assertTrue(token2.is_eol()) def testMultiline1(self): - tok = dns.tokenizer.Tokenizer('( foo\n\n bar\n)') + tok = dns.tokenizer.Tokenizer("( foo\n\n bar\n)") tokens = list(iter(tok)) - self.assertEqual(tokens, [Token(dns.tokenizer.IDENTIFIER, 'foo'), - Token(dns.tokenizer.IDENTIFIER, 'bar')]) + self.assertEqual( + tokens, + [ + Token(dns.tokenizer.IDENTIFIER, "foo"), + Token(dns.tokenizer.IDENTIFIER, "bar"), + ], + ) def testMultiline2(self): - tok = dns.tokenizer.Tokenizer('( foo\n\n bar\n)\n') + tok = dns.tokenizer.Tokenizer("( foo\n\n bar\n)\n") tokens = list(iter(tok)) - self.assertEqual(tokens, [Token(dns.tokenizer.IDENTIFIER, 'foo'), - Token(dns.tokenizer.IDENTIFIER, 'bar'), - Token(dns.tokenizer.EOL, '\n')]) + self.assertEqual( + tokens, + [ + Token(dns.tokenizer.IDENTIFIER, "foo"), + Token(dns.tokenizer.IDENTIFIER, "bar"), + Token(dns.tokenizer.EOL, "\n"), + ], + ) def testMultiline3(self): with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('foo)') + tok = dns.tokenizer.Tokenizer("foo)") list(iter(tok)) def testMultiline4(self): with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('((foo)') + tok = dns.tokenizer.Tokenizer("((foo)") list(iter(tok)) def testUnget1(self): - tok = dns.tokenizer.Tokenizer('foo') + tok = dns.tokenizer.Tokenizer("foo") t1 = tok.get() tok.unget(t1) t2 = tok.get() self.assertEqual(t1, t2) self.assertEqual(t1.ttype, dns.tokenizer.IDENTIFIER) - self.assertEqual(t1.value, 'foo') + self.assertEqual(t1.value, "foo") def testUnget2(self): with self.assertRaises(dns.tokenizer.UngetBufferFull): - tok = dns.tokenizer.Tokenizer('foo') + tok = dns.tokenizer.Tokenizer("foo") t1 = tok.get() tok.unget(t1) tok.unget(t1) def testGetEOL1(self): - tok = dns.tokenizer.Tokenizer('\n') + tok = dns.tokenizer.Tokenizer("\n") t = tok.get_eol() - self.assertEqual(t, '\n') + self.assertEqual(t, "\n") def testGetEOL2(self): - tok = dns.tokenizer.Tokenizer('') + tok = dns.tokenizer.Tokenizer("") t = tok.get_eol() - self.assertEqual(t, '') + self.assertEqual(t, "") def testEscapedDelimiter1(self): - tok = dns.tokenizer.Tokenizer(r'ch\ ld') + tok = dns.tokenizer.Tokenizer(r"ch\ ld") t = tok.get() self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER) - self.assertEqual(t.value, r'ch\ ld') + self.assertEqual(t.value, r"ch\ ld") def testEscapedDelimiter2(self): - tok = dns.tokenizer.Tokenizer(r'ch\032ld') + tok = dns.tokenizer.Tokenizer(r"ch\032ld") t = tok.get() self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER) - self.assertEqual(t.value, r'ch\032ld') + self.assertEqual(t.value, r"ch\032ld") def testEscapedDelimiter3(self): - tok = dns.tokenizer.Tokenizer(r'ch\ild') + tok = dns.tokenizer.Tokenizer(r"ch\ild") t = tok.get() self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER) - self.assertEqual(t.value, r'ch\ild') + self.assertEqual(t.value, r"ch\ild") def testEscapedDelimiter1u(self): - tok = dns.tokenizer.Tokenizer(r'ch\ ld') + tok = dns.tokenizer.Tokenizer(r"ch\ ld") t = tok.get().unescape() self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER) - self.assertEqual(t.value, r'ch ld') + self.assertEqual(t.value, r"ch ld") def testEscapedDelimiter2u(self): - tok = dns.tokenizer.Tokenizer(r'ch\032ld') + tok = dns.tokenizer.Tokenizer(r"ch\032ld") t = tok.get().unescape() self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER) - self.assertEqual(t.value, 'ch ld') + self.assertEqual(t.value, "ch ld") def testEscapedDelimiter3u(self): - tok = dns.tokenizer.Tokenizer(r'ch\ild') + tok = dns.tokenizer.Tokenizer(r"ch\ild") t = tok.get().unescape() self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER) - self.assertEqual(t.value, r'child') + self.assertEqual(t.value, r"child") def testGetUInt(self): - tok = dns.tokenizer.Tokenizer('1234') + tok = dns.tokenizer.Tokenizer("1234") v = tok.get_int() self.assertEqual(v, 1234) with self.assertRaises(dns.exception.SyntaxError): tok = dns.tokenizer.Tokenizer('"1234"') tok.get_int() with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('q1234') + tok = dns.tokenizer.Tokenizer("q1234") tok.get_int() with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('281474976710656') + tok = dns.tokenizer.Tokenizer("281474976710656") tok.get_uint48() with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('4294967296') + tok = dns.tokenizer.Tokenizer("4294967296") tok.get_uint32() with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('65536') + tok = dns.tokenizer.Tokenizer("65536") tok.get_uint16() with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('256') + tok = dns.tokenizer.Tokenizer("256") tok.get_uint8() # Even though it is badly named get_int(), it's really get_unit! with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('-1234') + tok = dns.tokenizer.Tokenizer("-1234") tok.get_int() # get_uint16 can do other bases too, and has a custom error # for base 8. - tok = dns.tokenizer.Tokenizer('177777') + tok = dns.tokenizer.Tokenizer("177777") self.assertEqual(tok.get_uint16(base=8), 65535) with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('200000') + tok = dns.tokenizer.Tokenizer("200000") tok.get_uint16(base=8) def testGetString(self): - tok = dns.tokenizer.Tokenizer('foo') + tok = dns.tokenizer.Tokenizer("foo") v = tok.get_string() - self.assertEqual(v, 'foo') + self.assertEqual(v, "foo") tok = dns.tokenizer.Tokenizer('"foo"') v = tok.get_string() - self.assertEqual(v, 'foo') - tok = dns.tokenizer.Tokenizer('abcdefghij') + self.assertEqual(v, "foo") + tok = dns.tokenizer.Tokenizer("abcdefghij") v = tok.get_string(max_length=10) - self.assertEqual(v, 'abcdefghij') + self.assertEqual(v, "abcdefghij") with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('abcdefghij') + tok = dns.tokenizer.Tokenizer("abcdefghij") tok.get_string(max_length=9) - tok = dns.tokenizer.Tokenizer('') + tok = dns.tokenizer.Tokenizer("") with self.assertRaises(dns.exception.SyntaxError): tok.get_string() def testMultiLineWithComment(self): - tok = dns.tokenizer.Tokenizer('( ; abc\n)') + tok = dns.tokenizer.Tokenizer("( ; abc\n)") tok.get_eol() # Nothing to assert here, as we're testing tok.get_eol() does NOT # raise. def testEOLAfterComment(self): - tok = dns.tokenizer.Tokenizer('; abc\n') + tok = dns.tokenizer.Tokenizer("; abc\n") t = tok.get() self.assertTrue(t.is_eol()) def testEOFAfterComment(self): - tok = dns.tokenizer.Tokenizer('; abc') + tok = dns.tokenizer.Tokenizer("; abc") t = tok.get() self.assertTrue(t.is_eof()) def testMultiLineWithEOFAfterComment(self): with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('( ; abc') + tok = dns.tokenizer.Tokenizer("( ; abc") tok.get_eol() def testEscapeUnexpectedEnd(self): with self.assertRaises(dns.exception.UnexpectedEnd): - tok = dns.tokenizer.Tokenizer('\\') + tok = dns.tokenizer.Tokenizer("\\") tok.get() def testEscapeBounds(self): with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('\\256') + tok = dns.tokenizer.Tokenizer("\\256") tok.get().unescape() with self.assertRaises(dns.exception.SyntaxError): - tok = dns.tokenizer.Tokenizer('\\256') + tok = dns.tokenizer.Tokenizer("\\256") tok.get().unescape_to_bytes() def testGetUngetRegetComment(self): - tok = dns.tokenizer.Tokenizer(';comment') + tok = dns.tokenizer.Tokenizer(";comment") t1 = tok.get(want_comment=True) tok.unget(t1) t2 = tok.get(want_comment=True) @@ -314,12 +323,12 @@ class TokenizerTestCase(unittest.TestCase): tok.get().unescape_to_bytes() def testTokenMisc(self): - t1 = dns.tokenizer.Token(dns.tokenizer.IDENTIFIER, 'hi') - t2 = dns.tokenizer.Token(dns.tokenizer.IDENTIFIER, 'hi') - t3 = dns.tokenizer.Token(dns.tokenizer.IDENTIFIER, 'there') + t1 = dns.tokenizer.Token(dns.tokenizer.IDENTIFIER, "hi") + t2 = dns.tokenizer.Token(dns.tokenizer.IDENTIFIER, "hi") + t3 = dns.tokenizer.Token(dns.tokenizer.IDENTIFIER, "there") self.assertEqual(t1, t2) - self.assertFalse(t1 == 'hi') # not NotEqual because we want to use == - self.assertNotEqual(t1, 'hi') + self.assertFalse(t1 == "hi") # not NotEqual because we want to use == + self.assertNotEqual(t1, "hi") self.assertNotEqual(t1, t3) self.assertEqual(str(t1), '3 "hi"') @@ -330,17 +339,17 @@ class TokenizerTestCase(unittest.TestCase): def testStdinFilename(self): tok = dns.tokenizer.Tokenizer() - self.assertEqual(tok.filename, '<stdin>') + self.assertEqual(tok.filename, "<stdin>") def testBytesLiteral(self): - tok = dns.tokenizer.Tokenizer(b'this is input') - self.assertEqual(tok.get().value, 'this') - self.assertEqual(tok.filename, '<string>') - tok = dns.tokenizer.Tokenizer(b'this is input', 'myfilename') - self.assertEqual(tok.filename, 'myfilename') + tok = dns.tokenizer.Tokenizer(b"this is input") + self.assertEqual(tok.get().value, "this") + self.assertEqual(tok.filename, "<string>") + tok = dns.tokenizer.Tokenizer(b"this is input", "myfilename") + self.assertEqual(tok.filename, "myfilename") def testUngetBranches(self): - tok = dns.tokenizer.Tokenizer(b' this is input') + tok = dns.tokenizer.Tokenizer(b" this is input") t = tok.get(want_leading=True) tok.unget(t) t = tok.get(want_leading=True) @@ -348,8 +357,8 @@ class TokenizerTestCase(unittest.TestCase): tok.unget(t) t = tok.get() self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER) - self.assertEqual(t.value, 'this') - tok = dns.tokenizer.Tokenizer(b'; this is input\n') + self.assertEqual(t.value, "this") + tok = dns.tokenizer.Tokenizer(b"; this is input\n") t = tok.get(want_comment=True) tok.unget(t) t = tok.get(want_comment=True) @@ -358,5 +367,6 @@ class TokenizerTestCase(unittest.TestCase): t = tok.get() self.assertEqual(t.ttype, dns.tokenizer.EOL) -if __name__ == '__main__': + +if __name__ == "__main__": unittest.main() diff --git a/tests/test_transaction.py b/tests/test_transaction.py index ce533c5..8e2744a 100644 --- a/tests/test_transaction.py +++ b/tests/test_transaction.py @@ -25,7 +25,7 @@ class DB(dns.transaction.TransactionManager): return Transaction(self, replacement, False) def origin_information(self): - return (dns.name.from_text('example'), True, dns.name.empty) + return (dns.name.from_text("example"), True, dns.name.empty) def get_class(self): return dns.rdataclass.IN @@ -79,136 +79,130 @@ class Transaction(dns.transaction.Transaction): def _set_origin(self, origin): pass + @pytest.fixture def db(): db = DB() - rrset = dns.rrset.from_text('content', 300, 'in', 'txt', 'content') + rrset = dns.rrset.from_text("content", 300, "in", "txt", "content") db.rdatasets[(rrset.name, rrset.rdtype, 0)] = rrset return db + def test_basic(db): # successful txn with db.writer() as txn: - rrset = dns.rrset.from_text('foo', 300, 'in', 'a', - '10.0.0.1', '10.0.0.2') + rrset = dns.rrset.from_text("foo", 300, "in", "a", "10.0.0.1", "10.0.0.2") txn.add(rrset) assert txn.name_exists(rrset.name) - assert db.rdatasets[(rrset.name, rrset.rdtype, 0)] == \ - rrset + assert db.rdatasets[(rrset.name, rrset.rdtype, 0)] == rrset # rollback with pytest.raises(Exception): with db.writer() as txn: - rrset2 = dns.rrset.from_text('foo', 300, 'in', 'a', - '10.0.0.3', '10.0.0.4') + rrset2 = dns.rrset.from_text("foo", 300, "in", "a", "10.0.0.3", "10.0.0.4") txn.add(rrset2) raise Exception() - assert db.rdatasets[(rrset.name, rrset.rdtype, 0)] == \ - rrset + assert db.rdatasets[(rrset.name, rrset.rdtype, 0)] == rrset with db.writer() as txn: txn.delete(rrset.name) - assert db.rdatasets.get((rrset.name, rrset.rdtype, 0)) \ - is None + assert db.rdatasets.get((rrset.name, rrset.rdtype, 0)) is None + def test_get(db): with db.writer() as txn: - content = dns.name.from_text('content', None) + content = dns.name.from_text("content", None) rdataset = txn.get(content, dns.rdatatype.TXT) assert rdataset is not None - assert rdataset[0].strings == (b'content',) + assert rdataset[0].strings == (b"content",) assert isinstance(rdataset, dns.rdataset.ImmutableRdataset) + def test_add(db): with db.writer() as txn: - rrset = dns.rrset.from_text('foo', 300, 'in', 'a', - '10.0.0.1', '10.0.0.2') + rrset = dns.rrset.from_text("foo", 300, "in", "a", "10.0.0.1", "10.0.0.2") txn.add(rrset) - rrset2 = dns.rrset.from_text('foo', 300, 'in', 'a', - '10.0.0.3', '10.0.0.4') + rrset2 = dns.rrset.from_text("foo", 300, "in", "a", "10.0.0.3", "10.0.0.4") txn.add(rrset2) - expected = dns.rrset.from_text('foo', 300, 'in', 'a', - '10.0.0.1', '10.0.0.2', - '10.0.0.3', '10.0.0.4') - assert db.rdatasets[(rrset.name, rrset.rdtype, 0)] == \ - expected + expected = dns.rrset.from_text( + "foo", 300, "in", "a", "10.0.0.1", "10.0.0.2", "10.0.0.3", "10.0.0.4" + ) + assert db.rdatasets[(rrset.name, rrset.rdtype, 0)] == expected + def test_replacement(db): with db.writer() as txn: - rrset = dns.rrset.from_text('foo', 300, 'in', 'a', - '10.0.0.1', '10.0.0.2') + rrset = dns.rrset.from_text("foo", 300, "in", "a", "10.0.0.1", "10.0.0.2") txn.add(rrset) - rrset2 = dns.rrset.from_text('foo', 300, 'in', 'a', - '10.0.0.3', '10.0.0.4') + rrset2 = dns.rrset.from_text("foo", 300, "in", "a", "10.0.0.3", "10.0.0.4") txn.replace(rrset2) - assert db.rdatasets[(rrset.name, rrset.rdtype, 0)] == \ - rrset2 + assert db.rdatasets[(rrset.name, rrset.rdtype, 0)] == rrset2 + def test_delete(db): with db.writer() as txn: - txn.delete(dns.name.from_text('nonexistent', None)) - content = dns.name.from_text('content', None) - content2 = dns.name.from_text('content2', None) + txn.delete(dns.name.from_text("nonexistent", None)) + content = dns.name.from_text("content", None) + content2 = dns.name.from_text("content2", None) txn.delete(content) assert not txn.name_exists(content) txn.delete(content2, dns.rdatatype.TXT) - rrset = dns.rrset.from_text('content', 300, 'in', 'txt', 'new-content') + rrset = dns.rrset.from_text("content", 300, "in", "txt", "new-content") txn.add(rrset) assert txn.name_exists(content) txn.delete(content, dns.rdatatype.TXT) assert not txn.name_exists(content) - rrset = dns.rrset.from_text('content2', 300, 'in', 'txt', 'new-content') + rrset = dns.rrset.from_text("content2", 300, "in", "txt", "new-content") txn.delete(rrset) content_keys = [k for k in db.rdatasets if k[0] == content] assert len(content_keys) == 0 + def test_delete_exact(db): with db.writer() as txn: - rrset = dns.rrset.from_text('content', 300, 'in', 'txt', 'bad-content') + rrset = dns.rrset.from_text("content", 300, "in", "txt", "bad-content") with pytest.raises(dns.transaction.DeleteNotExact): txn.delete_exact(rrset) - rrset = dns.rrset.from_text('content2', 300, 'in', 'txt', 'bad-content') + rrset = dns.rrset.from_text("content2", 300, "in", "txt", "bad-content") with pytest.raises(dns.transaction.DeleteNotExact): txn.delete_exact(rrset) with pytest.raises(dns.transaction.DeleteNotExact): txn.delete_exact(rrset.name) with pytest.raises(dns.transaction.DeleteNotExact): txn.delete_exact(rrset.name, dns.rdatatype.TXT) - rrset = dns.rrset.from_text('content', 300, 'in', 'txt', 'content') + rrset = dns.rrset.from_text("content", 300, "in", "txt", "content") txn.delete_exact(rrset) - assert db.rdatasets.get((rrset.name, rrset.rdtype, 0)) \ - is None + assert db.rdatasets.get((rrset.name, rrset.rdtype, 0)) is None + def test_parameter_forms(db): with db.writer() as txn: - foo = dns.name.from_text('foo', None) - rdataset = dns.rdataset.from_text('in', 'a', 300, - '10.0.0.1', '10.0.0.2') - rdata1 = dns.rdata.from_text('in', 'a', '10.0.0.3') - rdata2 = dns.rdata.from_text('in', 'a', '10.0.0.4') + foo = dns.name.from_text("foo", None) + rdataset = dns.rdataset.from_text("in", "a", 300, "10.0.0.1", "10.0.0.2") + rdata1 = dns.rdata.from_text("in", "a", "10.0.0.3") + rdata2 = dns.rdata.from_text("in", "a", "10.0.0.4") txn.add(foo, rdataset) txn.add(foo, 100, rdata1) txn.add(foo, 30, rdata2) - expected = dns.rrset.from_text('foo', 30, 'in', 'a', - '10.0.0.1', '10.0.0.2', - '10.0.0.3', '10.0.0.4') - assert db.rdatasets[(foo, rdataset.rdtype, 0)] == \ - expected + expected = dns.rrset.from_text( + "foo", 30, "in", "a", "10.0.0.1", "10.0.0.2", "10.0.0.3", "10.0.0.4" + ) + assert db.rdatasets[(foo, rdataset.rdtype, 0)] == expected with db.writer() as txn: txn.delete(foo, rdataset) txn.delete(foo, rdata1) txn.delete(foo, rdata2) - assert db.rdatasets.get((foo, rdataset.rdtype, 0)) \ - is None + assert db.rdatasets.get((foo, rdataset.rdtype, 0)) is None + def test_bad_parameters(db): with db.writer() as txn: with pytest.raises(TypeError): txn.add(1) with pytest.raises(TypeError): - rrset = dns.rrset.from_text('bar', 300, 'in', 'txt', 'bar') + rrset = dns.rrset.from_text("bar", 300, "in", "txt", "bar") txn.add(rrset, 1) with pytest.raises(ValueError): - foo = dns.name.from_text('foo', None) - rdata = dns.rdata.from_text('in', 'a', '10.0.0.3') + foo = dns.name.from_text("foo", None) + rdata = dns.rdata.from_text("in", "a", "10.0.0.3") txn.add(foo, 0x100000000, rdata) with pytest.raises(TypeError): txn.add(foo) @@ -217,21 +211,22 @@ def test_bad_parameters(db): with pytest.raises(TypeError): txn.add(foo, 300) with pytest.raises(TypeError): - txn.add(foo, 300, 'hi') + txn.add(foo, 300, "hi") with pytest.raises(TypeError): - txn.add(foo, 'hi') + txn.add(foo, "hi") with pytest.raises(TypeError): txn.delete() with pytest.raises(TypeError): txn.delete(1) + def test_cannot_store_non_origin_soa(db): with pytest.raises(ValueError): with db.writer() as txn: - rrset = dns.rrset.from_text('foo', 300, 'in', 'SOA', - '. . 1 2 3 4 5') + rrset = dns.rrset.from_text("foo", 300, "in", "SOA", ". . 1 2 3 4 5") txn.add(rrset) + example_text = """$TTL 3600 $ORIGIN example. @ soa foo bar 1 2 3 4 5 @@ -253,55 +248,58 @@ ns2 3600 IN A 10.0.0.2 ns3 3600 IN A 10.0.0.3 """ + @pytest.fixture(params=[dns.zone.Zone, dns.versioned.Zone]) def zone(request): return dns.zone.from_text(example_text, zone_factory=request.param) + def test_zone_basic(zone): with zone.writer() as txn: - txn.delete(dns.name.from_text('bar.foo', None)) - rd = dns.rdata.from_text('in', 'ns', 'ns3') + txn.delete(dns.name.from_text("bar.foo", None)) + rd = dns.rdata.from_text("in", "ns", "ns3") txn.add(dns.name.empty, 3600, rd) - rd = dns.rdata.from_text('in', 'a', '10.0.0.3') - txn.add(dns.name.from_text('ns3', None), 3600, rd) + rd = dns.rdata.from_text("in", "a", "10.0.0.3") + txn.add(dns.name.from_text("ns3", None), 3600, rd) output = zone.to_text() assert output == example_text_output + def test_explicit_rollback_and_commit(zone): with zone.writer() as txn: assert not txn.changed() - txn.delete(dns.name.from_text('bar.foo', None)) + txn.delete(dns.name.from_text("bar.foo", None)) txn.rollback() - assert zone.get_node('bar.foo') is not None + assert zone.get_node("bar.foo") is not None with zone.writer() as txn: assert not txn.changed() - txn.delete(dns.name.from_text('bar.foo', None)) + txn.delete(dns.name.from_text("bar.foo", None)) txn.commit() - assert zone.get_node('bar.foo') is None + assert zone.get_node("bar.foo") is None with pytest.raises(dns.transaction.AlreadyEnded): with zone.writer() as txn: txn.rollback() - txn.delete(dns.name.from_text('bar.foo', None)) + txn.delete(dns.name.from_text("bar.foo", None)) with pytest.raises(dns.transaction.AlreadyEnded): with zone.writer() as txn: txn.rollback() - txn.add('bar.foo', 300, dns.rdata.from_text('in', 'txt', 'hi')) + txn.add("bar.foo", 300, dns.rdata.from_text("in", "txt", "hi")) with pytest.raises(dns.transaction.AlreadyEnded): with zone.writer() as txn: txn.rollback() - txn.replace('bar.foo', 300, dns.rdata.from_text('in', 'txt', 'hi')) + txn.replace("bar.foo", 300, dns.rdata.from_text("in", "txt", "hi")) with pytest.raises(dns.transaction.AlreadyEnded): with zone.reader() as txn: txn.rollback() - txn.get('bar.foo', 'in', 'mx') + txn.get("bar.foo", "in", "mx") with pytest.raises(dns.transaction.AlreadyEnded): with zone.writer() as txn: txn.rollback() - txn.delete_exact('bar.foo') + txn.delete_exact("bar.foo") with pytest.raises(dns.transaction.AlreadyEnded): with zone.writer() as txn: txn.rollback() - txn.name_exists('bar.foo') + txn.name_exists("bar.foo") with pytest.raises(dns.transaction.AlreadyEnded): with zone.writer() as txn: txn.rollback() @@ -324,6 +322,7 @@ def test_explicit_rollback_and_commit(zone): for rdataset in txn: pass + def test_zone_changed(zone): # Read-only is not changed! with zone.reader() as txn: @@ -331,57 +330,60 @@ def test_zone_changed(zone): # delete an existing name with zone.writer() as txn: assert not txn.changed() - txn.delete(dns.name.from_text('bar.foo', None)) + txn.delete(dns.name.from_text("bar.foo", None)) assert txn.changed() # delete a nonexistent name with zone.writer() as txn: assert not txn.changed() - txn.delete(dns.name.from_text('unknown.bar.foo', None)) + txn.delete(dns.name.from_text("unknown.bar.foo", None)) assert not txn.changed() # delete a nonexistent rdataset from an extant node with zone.writer() as txn: assert not txn.changed() - txn.delete(dns.name.from_text('bar.foo', None), 'txt') + txn.delete(dns.name.from_text("bar.foo", None), "txt") assert not txn.changed() # add an rdataset to an extant Node with zone.writer() as txn: assert not txn.changed() - txn.add('bar.foo', 300, dns.rdata.from_text('in', 'txt', 'hi')) + txn.add("bar.foo", 300, dns.rdata.from_text("in", "txt", "hi")) assert txn.changed() # add an rdataset to a nonexistent Node with zone.writer() as txn: assert not txn.changed() - txn.add('foo.foo', 300, dns.rdata.from_text('in', 'txt', 'hi')) + txn.add("foo.foo", 300, dns.rdata.from_text("in", "txt", "hi")) assert txn.changed() + def test_zone_base_layer(zone): with zone.writer() as txn: # Get a set from the zone layer rdataset = txn.get(dns.name.empty, dns.rdatatype.NS, dns.rdatatype.NONE) - expected = dns.rdataset.from_text('in', 'ns', 300, 'ns1', 'ns2') + expected = dns.rdataset.from_text("in", "ns", 300, "ns1", "ns2") assert rdataset == expected + def test_zone_transaction_layer(zone): with zone.writer() as txn: # Make a change - rd = dns.rdata.from_text('in', 'ns', 'ns3') + rd = dns.rdata.from_text("in", "ns", "ns3") txn.add(dns.name.empty, 3600, rd) # Get a set from the transaction layer - expected = dns.rdataset.from_text('in', 'ns', 300, 'ns1', 'ns2', 'ns3') + expected = dns.rdataset.from_text("in", "ns", 300, "ns1", "ns2", "ns3") rdataset = txn.get(dns.name.empty, dns.rdatatype.NS, dns.rdatatype.NONE) assert rdataset == expected assert txn.name_exists(dns.name.empty) - ns1 = dns.name.from_text('ns1', None) + ns1 = dns.name.from_text("ns1", None) assert txn.name_exists(ns1) - ns99 = dns.name.from_text('ns99', None) + ns99 = dns.name.from_text("ns99", None) assert not txn.name_exists(ns99) + def test_zone_add_and_delete(zone): with zone.writer() as txn: - a99 = dns.name.from_text('a99', None) - a100 = dns.name.from_text('a100', None) - a101 = dns.name.from_text('a101', None) - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.99') + a99 = dns.name.from_text("a99", None) + a100 = dns.name.from_text("a100", None) + a101 = dns.name.from_text("a101", None) + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.99") txn.add(a99, rds) txn.delete(a99, dns.rdatatype.A) txn.delete(a100, dns.rdatatype.A) @@ -389,7 +391,7 @@ def test_zone_add_and_delete(zone): assert not txn.name_exists(a99) assert not txn.name_exists(a100) assert not txn.name_exists(a101) - ns1 = dns.name.from_text('ns1', None) + ns1 = dns.name.from_text("ns1", None) txn.delete(ns1, dns.rdatatype.A) assert not txn.name_exists(ns1) with zone.writer() as txn: @@ -402,32 +404,35 @@ def test_zone_add_and_delete(zone): assert not txn.name_exists(a99) assert txn.name_exists(a100) + def test_write_after_rollback(zone): with pytest.raises(ExpectedException): with zone.writer() as txn: - a99 = dns.name.from_text('a99', None) - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.99') + a99 = dns.name.from_text("a99", None) + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.99") txn.add(a99, rds) raise ExpectedException with zone.writer() as txn: - a99 = dns.name.from_text('a99', None) - rds = dns.rdataset.from_text('in', 'a', 300, '10.99.99.99') + a99 = dns.name.from_text("a99", None) + rds = dns.rdataset.from_text("in", "a", 300, "10.99.99.99") txn.add(a99, rds) - assert zone.get_rdataset('a99', 'a') == rds + assert zone.get_rdataset("a99", "a") == rds + def test_zone_get_deleted(zone): with zone.writer() as txn: - ns1 = dns.name.from_text('ns1', None) + ns1 = dns.name.from_text("ns1", None) assert txn.get(ns1, dns.rdatatype.A) is not None txn.delete(ns1) assert txn.get(ns1, dns.rdatatype.A) is None - ns2 = dns.name.from_text('ns2', None) + ns2 = dns.name.from_text("ns2", None) txn.delete(ns2, dns.rdatatype.A) assert txn.get(ns2, dns.rdatatype.A) is None + def test_zone_bad_class(zone): with zone.writer() as txn: - rds = dns.rdataset.from_text('ch', 'ns', 300, 'ns1', 'ns2') + rds = dns.rdataset.from_text("ch", "ns", 300, "ns1", "ns2") with pytest.raises(ValueError): txn.add(dns.name.empty, rds) with pytest.raises(ValueError): @@ -435,30 +440,31 @@ def test_zone_bad_class(zone): with pytest.raises(ValueError): txn.delete(dns.name.empty, rds) + def test_update_serial(zone): # basic with zone.writer() as txn: txn.update_serial() - rdataset = zone.find_rdataset('@', 'soa') + rdataset = zone.find_rdataset("@", "soa") assert rdataset[0].serial == 2 # max with zone.writer() as txn: - txn.update_serial(0xffffffff, False) - rdataset = zone.find_rdataset('@', 'soa') - assert rdataset[0].serial == 0xffffffff + txn.update_serial(0xFFFFFFFF, False) + rdataset = zone.find_rdataset("@", "soa") + assert rdataset[0].serial == 0xFFFFFFFF # wraparound to 1 with zone.writer() as txn: txn.update_serial() - rdataset = zone.find_rdataset('@', 'soa') + rdataset = zone.find_rdataset("@", "soa") assert rdataset[0].serial == 1 # trying to set to zero sets to 1 with zone.writer() as txn: txn.update_serial(0, False) - rdataset = zone.find_rdataset('@', 'soa') + rdataset = zone.find_rdataset("@", "soa") assert rdataset[0].serial == 1 with pytest.raises(KeyError): with zone.writer() as txn: - txn.update_serial(name=dns.name.from_text('unknown', None)) + txn.update_serial(name=dns.name.from_text("unknown", None)) with pytest.raises(ValueError): with zone.writer() as txn: txn.update_serial(-1) @@ -466,14 +472,16 @@ def test_update_serial(zone): with zone.writer() as txn: txn.update_serial(2**31) + class ExpectedException(Exception): pass + def test_zone_rollback(zone): - a99 = dns.name.from_text('a99.example.') + a99 = dns.name.from_text("a99.example.") try: with zone.writer() as txn: - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.99') + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.99") txn.add(a99, rds) assert txn.name_exists(a99) raise ExpectedException @@ -481,12 +489,14 @@ def test_zone_rollback(zone): pass assert not zone.get_node(a99) + def test_zone_ooz_name(zone): with zone.writer() as txn: with pytest.raises(KeyError): - a99 = dns.name.from_text('a99.not-example.') + a99 = dns.name.from_text("a99.not-example.") assert txn.name_exists(a99) + def test_zone_iteration(zone): expected = {} for (name, rdataset) in zone.iterate_rdatasets(): @@ -497,8 +507,9 @@ def test_zone_iteration(zone): actual[(name, rdataset.rdtype, rdataset.covers)] = rdataset assert actual == expected + def test_iteration_in_replacement_txn(zone): - rds = dns.rdataset.from_text('in', 'a', 300, '1.2.3.4', '5.6.7.8') + rds = dns.rdataset.from_text("in", "a", 300, "1.2.3.4", "5.6.7.8") expected = {} expected[(dns.name.empty, rds.rdtype, rds.covers)] = rds with zone.writer(True) as txn: @@ -508,8 +519,9 @@ def test_iteration_in_replacement_txn(zone): actual[(name, rdataset.rdtype, rdataset.covers)] = rdataset assert actual == expected + def test_replacement_commit(zone): - rds = dns.rdataset.from_text('in', 'a', 300, '1.2.3.4', '5.6.7.8') + rds = dns.rdataset.from_text("in", "a", 300, "1.2.3.4", "5.6.7.8") expected = {} expected[(dns.name.empty, rds.rdtype, rds.covers)] = rds with zone.writer(True) as txn: @@ -520,9 +532,10 @@ def test_replacement_commit(zone): actual[(name, rdataset.rdtype, rdataset.covers)] = rdataset assert actual == expected + def test_replacement_get(zone): with zone.writer(True) as txn: - rds = txn.get(dns.name.empty, 'soa') + rds = txn.get(dns.name.empty, "soa") assert rds is None @@ -530,14 +543,16 @@ def test_replacement_get(zone): def vzone(): return dns.zone.from_text(example_text, zone_factory=dns.versioned.Zone) + def test_vzone_read_only(vzone): with vzone.reader() as txn: rdataset = txn.get(dns.name.empty, dns.rdatatype.NS, dns.rdatatype.NONE) - expected = dns.rdataset.from_text('in', 'ns', 300, 'ns1', 'ns2') + expected = dns.rdataset.from_text("in", "ns", 300, "ns1", "ns2") assert rdataset == expected with pytest.raises(dns.transaction.ReadOnly): txn.replace(dns.name.empty, expected) + def test_vzone_multiple_versions(vzone): assert len(vzone._versions) == 1 vzone.set_max_versions(None) # unlimited! @@ -547,39 +562,41 @@ def test_vzone_multiple_versions(vzone): txn.update_serial() with vzone.writer() as txn: txn.update_serial(1000, False) - rdataset = vzone.find_rdataset('@', 'soa') + rdataset = vzone.find_rdataset("@", "soa") assert rdataset[0].serial == 1000 assert len(vzone._versions) == 4 with vzone.reader(id=5) as txn: assert txn.version.id == 5 - rdataset = txn.get('@', 'soa') + rdataset = txn.get("@", "soa") assert rdataset[0].serial == 1000 with vzone.reader(serial=1000) as txn: assert txn.version.id == 5 - rdataset = txn.get('@', 'soa') + rdataset = txn.get("@", "soa") assert rdataset[0].serial == 1000 vzone.set_max_versions(2) assert len(vzone._versions) == 2 # The ones that survived should be 3 and 1000 - rdataset = vzone._versions[0].get_rdataset(dns.name.empty, - dns.rdatatype.SOA, - dns.rdatatype.NONE) + rdataset = vzone._versions[0].get_rdataset( + dns.name.empty, dns.rdatatype.SOA, dns.rdatatype.NONE + ) assert rdataset[0].serial == 3 - rdataset = vzone._versions[1].get_rdataset(dns.name.empty, - dns.rdatatype.SOA, - dns.rdatatype.NONE) + rdataset = vzone._versions[1].get_rdataset( + dns.name.empty, dns.rdatatype.SOA, dns.rdatatype.NONE + ) assert rdataset[0].serial == 1000 with pytest.raises(ValueError): vzone.set_max_versions(0) + # for debugging if needed def _dump(zone): for v in zone._versions: - print('VERSION', v.id) + print("VERSION", v.id) for (name, n) in v.nodes.items(): for rdataset in n: print(rdataset.to_text(name)) + def test_vzone_open_txn_pins_versions(vzone): assert len(vzone._versions) == 1 vzone.set_max_versions(None) # unlimited! @@ -592,11 +609,11 @@ def test_vzone_open_txn_pins_versions(vzone): with vzone.reader(id=2) as txn: vzone.set_max_versions(1) with vzone.reader(id=3) as txn: - rdataset = txn.get('@', 'soa') + rdataset = txn.get("@", "soa") assert rdataset[0].serial == 2 assert len(vzone._versions) == 4 assert len(vzone._versions) == 1 - rdataset = vzone.find_rdataset('@', 'soa') + rdataset = vzone.find_rdataset("@", "soa") assert vzone._versions[0].id == 5 assert rdataset[0].serial == 4 @@ -612,16 +629,16 @@ try: # wait until two blocks while len(zone._write_waiters) == 0: time.sleep(0.01) - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.98') - txn.add('a98', rds) + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.98") + txn.add("a98", rds) def run_two(zone): # wait until one has the lock so we know we will block if we # get the call done before the sleep in one completes one_got_lock.wait() with zone.writer() as txn: - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.99') - txn.add('a99', rds) + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.99") + txn.add("a99", rds) def test_vzone_concurrency(vzone): t1 = threading.Thread(target=run_one, args=(vzone,)) @@ -631,8 +648,8 @@ try: t1.join() t2.join() with vzone.reader() as txn: - assert txn.name_exists('a98') - assert txn.name_exists('a99') + assert txn.name_exists("a98") + assert txn.name_exists("a99") except ImportError: # pragma: no cover pass diff --git a/tests/test_tsig.py b/tests/test_tsig.py index 4c793d5..6571d5b 100644 --- a/tests/test_tsig.py +++ b/tests/test_tsig.py @@ -11,30 +11,25 @@ import dns.tsigkeyring import dns.message import dns.rdtypes.ANY.TKEY -keyring = dns.tsigkeyring.from_text( - { - 'keyname.' : 'NjHwPsMKjdN++dOfE5iAiQ==' - } -) +keyring = dns.tsigkeyring.from_text({"keyname.": "NjHwPsMKjdN++dOfE5iAiQ=="}) -keyname = dns.name.from_text('keyname') +keyname = dns.name.from_text("keyname") class TSIGTestCase(unittest.TestCase): - def test_get_context(self): - key = dns.tsig.Key('foo.com', 'abcd', 'hmac-sha256') + key = dns.tsig.Key("foo.com", "abcd", "hmac-sha256") ctx = dns.tsig.get_context(key) - self.assertEqual(ctx.name, 'hmac-sha256') - key = dns.tsig.Key('foo.com', 'abcd', 'hmac-sha512') + self.assertEqual(ctx.name, "hmac-sha256") + key = dns.tsig.Key("foo.com", "abcd", "hmac-sha512") ctx = dns.tsig.get_context(key) - self.assertEqual(ctx.name, 'hmac-sha512') - bogus = dns.tsig.Key('foo.com', 'abcd', 'bogus') + self.assertEqual(ctx.name, "hmac-sha512") + bogus = dns.tsig.Key("foo.com", "abcd", "bogus") with self.assertRaises(NotImplementedError): dns.tsig.get_context(bogus) def test_tsig_message_properties(self): - m = dns.message.make_query('example', 'a') + m = dns.message.make_query("example", "a") self.assertIsNone(m.keyname) self.assertIsNone(m.keyalgorithm) self.assertIsNone(m.tsig_error) @@ -42,77 +37,76 @@ class TSIGTestCase(unittest.TestCase): self.assertEqual(m.keyname, keyname) self.assertEqual(m.keyalgorithm, dns.tsig.default_algorithm) self.assertEqual(m.tsig_error, dns.rcode.NOERROR) - m = dns.message.make_query('example', 'a') + m = dns.message.make_query("example", "a") m.use_tsig(keyring, keyname, tsig_error=dns.rcode.BADKEY) self.assertEqual(m.tsig_error, dns.rcode.BADKEY) def test_verify_mac_for_context(self): - key = dns.tsig.Key('foo.com', 'abcd', 'hmac-sha512') + key = dns.tsig.Key("foo.com", "abcd", "hmac-sha512") ctx = dns.tsig.get_context(key) - bad_expected = b'xxxxxxxxxx' + bad_expected = b"xxxxxxxxxx" with self.assertRaises(dns.tsig.BadSignature): ctx.verify(bad_expected) def test_validate(self): # make message and grab the TSIG - m = dns.message.make_query('example', 'a') + m = dns.message.make_query("example", "a") m.use_tsig(keyring, keyname, algorithm=dns.tsig.HMAC_SHA256) w = m.to_wire() tsig = m.tsig[0] # get the time and create a key with matching characteristics now = int(time.time()) - key = dns.tsig.Key('foo.com', 'abcd', 'hmac-sha256') + key = dns.tsig.Key("foo.com", "abcd", "hmac-sha256") # add enough to the time to take it over the fudge amount with self.assertRaises(dns.tsig.BadTime): - dns.tsig.validate(w, key, dns.name.from_text('foo.com'), - tsig, now + 1000, b'', 0) + dns.tsig.validate( + w, key, dns.name.from_text("foo.com"), tsig, now + 1000, b"", 0 + ) # change the key name with self.assertRaises(dns.tsig.BadKey): - dns.tsig.validate(w, key, dns.name.from_text('bar.com'), - tsig, now, b'', 0) + dns.tsig.validate(w, key, dns.name.from_text("bar.com"), tsig, now, b"", 0) # change the key algorithm - key = dns.tsig.Key('foo.com', 'abcd', 'hmac-sha512') + key = dns.tsig.Key("foo.com", "abcd", "hmac-sha512") with self.assertRaises(dns.tsig.BadAlgorithm): - dns.tsig.validate(w, key, dns.name.from_text('foo.com'), - tsig, now, b'', 0) + dns.tsig.validate(w, key, dns.name.from_text("foo.com"), tsig, now, b"", 0) def test_gssapi_context(self): def verify_signature(data, mac): - if data == b'throw': + if data == b"throw": raise Exception return None # mock out the gssapi context to return some dummy values gssapi_context_mock = Mock() - gssapi_context_mock.get_signature.return_value = b'xxxxxxxxxxx' + gssapi_context_mock.get_signature.return_value = b"xxxxxxxxxxx" gssapi_context_mock.verify_signature.side_effect = verify_signature # create the key and add it to the keyring - keyname = 'gsstsigtest' - key = dns.tsig.Key(keyname, gssapi_context_mock, 'gss-tsig') + keyname = "gsstsigtest" + key = dns.tsig.Key(keyname, gssapi_context_mock, "gss-tsig") ctx = dns.tsig.get_context(key) - self.assertEqual(ctx.name, 'gss-tsig') + self.assertEqual(ctx.name, "gss-tsig") gsskeyname = dns.name.from_text(keyname) keyring[gsskeyname] = key # make sure we can get the keyring (no exception == success) text = dns.tsigkeyring.to_text(keyring) - self.assertNotEqual(text, '') + self.assertNotEqual(text, "") # test exceptional case for _verify_mac_for_context with self.assertRaises(dns.tsig.BadSignature): - ctx.update(b'throw') - ctx.verify(b'bogus') + ctx.update(b"throw") + ctx.verify(b"bogus") gssapi_context_mock.verify_signature.assert_called() self.assertEqual(gssapi_context_mock.verify_signature.call_count, 1) # simulate case where TKEY message is used to establish the context; # first, the query from the client - tkey_message = dns.message.make_query(keyname, 'tkey', 'any') + tkey_message = dns.message.make_query(keyname, "tkey", "any") # test existent/non-existent keys in the keyring adapted_keyring = dns.tsig.GSSTSigAdapter(keyring) @@ -127,20 +121,28 @@ class TSIGTestCase(unittest.TestCase): # create a response, TKEY and turn it into bytes, simulating the server # sending the response to the query tkey_response = dns.message.make_response(tkey_message) - key = base64.b64decode('KEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEY') - tkey = dns.rdtypes.ANY.TKEY.TKEY(dns.rdataclass.ANY, - dns.rdatatype.TKEY, - dns.name.from_text('gss-tsig.'), - 1594203795, 1594206664, - 3, 0, key) + key = base64.b64decode("KEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEYKEY") + tkey = dns.rdtypes.ANY.TKEY.TKEY( + dns.rdataclass.ANY, + dns.rdatatype.TKEY, + dns.name.from_text("gss-tsig."), + 1594203795, + 1594206664, + 3, + 0, + key, + ) # add the TKEY answer and sign it tkey_response.set_rcode(dns.rcode.NOERROR) tkey_response.answer = [ - dns.rrset.from_rdata(dns.name.from_text(keyname), 0, tkey)] - tkey_response.use_tsig(keyring=dns.tsig.GSSTSigAdapter(keyring), - keyname=gsskeyname, - algorithm=dns.tsig.GSS_TSIG) + dns.rrset.from_rdata(dns.name.from_text(keyname), 0, tkey) + ] + tkey_response.use_tsig( + keyring=dns.tsig.GSSTSigAdapter(keyring), + keyname=gsskeyname, + algorithm=dns.tsig.GSS_TSIG, + ) # "send" it to the client tkey_wire = tkey_response.to_wire() @@ -158,7 +160,7 @@ class TSIGTestCase(unittest.TestCase): # create example message and go to/from wire to simulate sign/verify # of regular messages - a_message = dns.message.make_query('example', 'a') + a_message = dns.message.make_query("example", "a") a_message.use_tsig(dns.tsig.GSSTSigAdapter(keyring), gsskeyname) a_wire = a_message.to_wire() # not raising is passing @@ -171,14 +173,14 @@ class TSIGTestCase(unittest.TestCase): self.assertEqual(gssapi_context_mock.verify_signature.call_count, 3) def test_sign_and_validate(self): - m = dns.message.make_query('example', 'a') + m = dns.message.make_query("example", "a") m.use_tsig(keyring, keyname) w = m.to_wire() # not raising is passing dns.message.from_wire(w, keyring) def test_validate_with_bad_keyring(self): - m = dns.message.make_query('example', 'a') + m = dns.message.make_query("example", "a") m.use_tsig(keyring, keyname) w = m.to_wire() @@ -190,14 +192,14 @@ class TSIGTestCase(unittest.TestCase): dns.message.from_wire(w, lambda m, n: None) def test_sign_and_validate_with_other_data(self): - m = dns.message.make_query('example', 'a') - m.use_tsig(keyring, keyname, other_data=b'other') + m = dns.message.make_query("example", "a") + m.use_tsig(keyring, keyname, other_data=b"other") w = m.to_wire() # not raising is passing dns.message.from_wire(w, keyring) def test_sign_respond_and_validate(self): - mq = dns.message.make_query('example', 'a') + mq = dns.message.make_query("example", "a") mq.use_tsig(keyring, keyname) wq = mq.to_wire() mq_with_tsig = dns.message.from_wire(wq, keyring) @@ -206,30 +208,33 @@ class TSIGTestCase(unittest.TestCase): wr = mr.to_wire() dns.message.from_wire(wr, keyring, request_mac=mq_with_tsig.mac) - def make_message_pair(self, qname='example', rdtype='A', tsig_error=0): + def make_message_pair(self, qname="example", rdtype="A", tsig_error=0): q = dns.message.make_query(qname, rdtype) q.use_tsig(keyring=keyring, keyname=keyname) q.to_wire() # to set q.mac r = dns.message.make_response(q, tsig_error=tsig_error) - return(q, r) + return (q, r) def test_peer_errors(self): - items = [(dns.rcode.BADSIG, dns.tsig.PeerBadSignature), - (dns.rcode.BADKEY, dns.tsig.PeerBadKey), - (dns.rcode.BADTIME, dns.tsig.PeerBadTime), - (dns.rcode.BADTRUNC, dns.tsig.PeerBadTruncation), - (99, dns.tsig.PeerError), - ] + items = [ + (dns.rcode.BADSIG, dns.tsig.PeerBadSignature), + (dns.rcode.BADKEY, dns.tsig.PeerBadKey), + (dns.rcode.BADTIME, dns.tsig.PeerBadTime), + (dns.rcode.BADTRUNC, dns.tsig.PeerBadTruncation), + (99, dns.tsig.PeerError), + ] for err, ex in items: q, r = self.make_message_pair(tsig_error=err) w = r.to_wire() + def bad(): dns.message.from_wire(w, keyring=keyring, request_mac=q.mac) + self.assertRaises(ex, bad) def _test_truncated_algorithm(self, alg, length): - key = dns.tsig.Key('foo', b'abcdefg', algorithm=alg) - q = dns.message.make_query('example', 'a') + key = dns.tsig.Key("foo", b"abcdefg", algorithm=alg) + q = dns.message.make_query("example", "a") q.use_tsig(key) q2 = dns.message.from_wire(q.to_wire(), keyring=key) @@ -247,22 +252,22 @@ class TSIGTestCase(unittest.TestCase): self._test_truncated_algorithm(dns.tsig.HMAC_SHA512_256, 256) def _test_text_format(self, alg): - key = dns.tsig.Key('foo', b'abcdefg', algorithm=alg) - q = dns.message.make_query('example', 'a') + key = dns.tsig.Key("foo", b"abcdefg", algorithm=alg) + q = dns.message.make_query("example", "a") q.use_tsig(key) _ = q.to_wire() text = q.tsig[0].to_text() - tsig2 = dns.rdata.from_text('ANY', 'TSIG', text) + tsig2 = dns.rdata.from_text("ANY", "TSIG", text) self.assertEqual(tsig2, q.tsig[0]) - q = dns.message.make_query('example', 'a') - q.use_tsig(key, other_data=b'abc') + q = dns.message.make_query("example", "a") + q.use_tsig(key, other_data=b"abc") q.use_tsig(key) _ = q.to_wire() text = q.tsig[0].to_text() - tsig2 = dns.rdata.from_text('ANY', 'TSIG', text) + tsig2 = dns.rdata.from_text("ANY", "TSIG", text) self.assertEqual(tsig2, q.tsig[0]) def test_text_hmac_sha256_128(self): @@ -275,15 +280,16 @@ class TSIGTestCase(unittest.TestCase): self._test_text_format(dns.tsig.HMAC_SHA512_256) def test_non_gss_key_repr(self): - key = dns.tsig.Key('foo', b'0123456789abcdef' * 2, - algorithm=dns.tsig.HMAC_SHA256) - self.assertEqual(repr(key), - "<DNS key name='foo.', algorithm='hmac-sha256.', " + - "secret=" + - "'MDEyMzQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWY='>") + key = dns.tsig.Key( + "foo", b"0123456789abcdef" * 2, algorithm=dns.tsig.HMAC_SHA256 + ) + self.assertEqual( + repr(key), + "<DNS key name='foo.', algorithm='hmac-sha256.', " + + "secret=" + + "'MDEyMzQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWY='>", + ) def test_gss_key_repr(self): - key = dns.tsig.Key('foo', None, - algorithm=dns.tsig.GSS_TSIG) - self.assertEqual(repr(key), - "<DNS key name='foo.', algorithm='gss-tsig.'>") + key = dns.tsig.Key("foo", None, algorithm=dns.tsig.GSS_TSIG) + self.assertEqual(repr(key), "<DNS key name='foo.', algorithm='gss-tsig.'>") diff --git a/tests/test_tsigkeyring.py b/tests/test_tsigkeyring.py index 47f8806..f8c889e 100644 --- a/tests/test_tsigkeyring.py +++ b/tests/test_tsigkeyring.py @@ -6,26 +6,20 @@ import unittest import dns.tsig import dns.tsigkeyring -text_keyring = { - 'keyname.' : ('hmac-sha256.', 'NjHwPsMKjdN++dOfE5iAiQ==') -} +text_keyring = {"keyname.": ("hmac-sha256.", "NjHwPsMKjdN++dOfE5iAiQ==")} -alt_text_keyring = { - 'keyname.' : (dns.tsig.HMAC_SHA256, 'NjHwPsMKjdN++dOfE5iAiQ==') -} +alt_text_keyring = {"keyname.": (dns.tsig.HMAC_SHA256, "NjHwPsMKjdN++dOfE5iAiQ==")} -old_text_keyring = { - 'keyname.' : 'NjHwPsMKjdN++dOfE5iAiQ==' -} +old_text_keyring = {"keyname.": "NjHwPsMKjdN++dOfE5iAiQ=="} -key = dns.tsig.Key('keyname.', 'NjHwPsMKjdN++dOfE5iAiQ==') +key = dns.tsig.Key("keyname.", "NjHwPsMKjdN++dOfE5iAiQ==") -rich_keyring = { key.name : key } +rich_keyring = {key.name: key} -old_rich_keyring = { key.name : key.secret } +old_rich_keyring = {key.name: key.secret} -class TSIGKeyRingTestCase(unittest.TestCase): +class TSIGKeyRingTestCase(unittest.TestCase): def test_from_text(self): """text keyring -> rich keyring""" rkeyring = dns.tsigkeyring.from_text(text_keyring) diff --git a/tests/test_ttl.py b/tests/test_ttl.py index 2bf298e..d566f41 100644 --- a/tests/test_ttl.py +++ b/tests/test_ttl.py @@ -4,33 +4,33 @@ import unittest import dns.ttl -class TTLTestCase(unittest.TestCase): +class TTLTestCase(unittest.TestCase): def test_bind_style_ok(self): - ttl = dns.ttl.from_text('2w1d1h1m1s') + ttl = dns.ttl.from_text("2w1d1h1m1s") self.assertEqual(ttl, 2 * 604800 + 86400 + 3600 + 60 + 1) def test_bind_style_ok2(self): # no one should do this, but it is legal! :) - ttl = dns.ttl.from_text('1s2w1m1d1h') + ttl = dns.ttl.from_text("1s2w1m1d1h") self.assertEqual(ttl, 2 * 604800 + 86400 + 3600 + 60 + 1) def test_bind_style_bad_unit(self): with self.assertRaises(dns.ttl.BadTTL): - dns.ttl.from_text('5y') + dns.ttl.from_text("5y") def test_bind_style_no_unit(self): with self.assertRaises(dns.ttl.BadTTL): - dns.ttl.from_text('1d5') + dns.ttl.from_text("1d5") def test_bind_style_leading_unit(self): with self.assertRaises(dns.ttl.BadTTL): - dns.ttl.from_text('s') + dns.ttl.from_text("s") def test_bind_style_unit_without_digits(self): with self.assertRaises(dns.ttl.BadTTL): - dns.ttl.from_text('1mw') + dns.ttl.from_text("1mw") def test_empty(self): with self.assertRaises(dns.ttl.BadTTL): - dns.ttl.from_text('') + dns.ttl.from_text("") diff --git a/tests/test_update.py b/tests/test_update.py index 3abec93..c1dea82 100644 --- a/tests/test_update.py +++ b/tests/test_update.py @@ -23,72 +23,70 @@ import dns.rdata import dns.rdataset import dns.tsigkeyring + def hextowire(hex): - return binascii.unhexlify(hex.replace(' ', '').encode()) + return binascii.unhexlify(hex.replace(" ", "").encode()) + goodwire = hextowire( - '0001 2800 0001 0005 0007 0000' - '076578616d706c6500 0006 0001' - '03666f6fc00c 00ff 00ff 00000000 0000' - 'c019 0001 00ff 00000000 0000' - '03626172c00c 0001 0001 00000000 0004 0a000005' - '05626c617a32c00c 00ff 00fe 00000000 0000' - 'c049 0001 00fe 00000000 0000' - 'c019 0001 00ff 00000000 0000' - 'c019 0001 0001 0000012c 0004 0a000001' - 'c019 0001 0001 0000012c 0004 0a000002' - 'c035 0001 0001 0000012c 0004 0a000003' - 'c035 0001 00fe 00000000 0004 0a000004' - '04626c617ac00c 0001 00ff 00000000 0000' - 'c049 00ff 00ff 00000000 0000' + "0001 2800 0001 0005 0007 0000" + "076578616d706c6500 0006 0001" + "03666f6fc00c 00ff 00ff 00000000 0000" + "c019 0001 00ff 00000000 0000" + "03626172c00c 0001 0001 00000000 0004 0a000005" + "05626c617a32c00c 00ff 00fe 00000000 0000" + "c049 0001 00fe 00000000 0000" + "c019 0001 00ff 00000000 0000" + "c019 0001 0001 0000012c 0004 0a000001" + "c019 0001 0001 0000012c 0004 0a000002" + "c035 0001 0001 0000012c 0004 0a000003" + "c035 0001 00fe 00000000 0004 0a000004" + "04626c617ac00c 0001 00ff 00000000 0000" + "c049 00ff 00ff 00000000 0000" ) goodwirenone = hextowire( - '0001 2800 0001 0000 0001 0000' - '076578616d706c6500 0006 0001' - '03666f6fc00c 0001 00fe 00000000 0004 01020304' + "0001 2800 0001 0000 0001 0000" + "076578616d706c6500 0006 0001" + "03666f6fc00c 0001 00fe 00000000 0004 01020304" ) badwirenone = hextowire( - '0001 2800 0001 0003 0000 0000' - '076578616d706c6500 0006 0001' - '03666f6fc00c 00ff 00ff 00000000 0000' - 'c019 0001 00ff 00000000 0000' - 'c019 0001 00fe 00000000 0004 01020304' + "0001 2800 0001 0003 0000 0000" + "076578616d706c6500 0006 0001" + "03666f6fc00c 00ff 00ff 00000000 0000" + "c019 0001 00ff 00000000 0000" + "c019 0001 00fe 00000000 0004 01020304" ) badwireany = hextowire( - '0001 2800 0001 0002 0000 0000' - '076578616d706c6500 0006 0001' - '03666f6fc00c 00ff 00ff 00000000 0000' - 'c019 0001 00ff 00000000 0004 01020304' + "0001 2800 0001 0002 0000 0000" + "076578616d706c6500 0006 0001" + "03666f6fc00c 00ff 00ff 00000000 0000" + "c019 0001 00ff 00000000 0004 01020304" ) badwireanyany = hextowire( - '0001 2800 0001 0001 0000 0000' - '076578616d706c6500 0006 0001' - '03666f6fc00c 00ff 00ff 00000000 0004 01020304' + "0001 2800 0001 0001 0000 0000" + "076578616d706c6500 0006 0001" + "03666f6fc00c 00ff 00ff 00000000 0004 01020304" ) badwirezonetype = hextowire( - '0001 2800 0001 0000 0000 0000' - '076578616d706c6500 0001 0001' + "0001 2800 0001 0000 0000 0000" "076578616d706c6500 0001 0001" ) badwirezoneclass = hextowire( - '0001 2800 0001 0000 0000 0000' - '076578616d706c6500 0006 00ff' + "0001 2800 0001 0000 0000 0000" "076578616d706c6500 0006 00ff" ) badwirezonemulti = hextowire( - '0001 2800 0002 0000 0000 0000' - '076578616d706c6500 0006 0001' - 'c019 0006 0001' + "0001 2800 0002 0000 0000 0000" "076578616d706c6500 0006 0001" "c019 0006 0001" ) badwirenozone = hextowire( - '0001 2800 0000 0000 0001 0000' - '03666f6f076578616d706c6500 0001 0001 00000030 0004 01020304' + "0001 2800 0000 0000 0001 0000" + "03666f6f076578616d706c6500 0001 0001 00000030 0004 01020304" ) update_text = """id 1 @@ -140,116 +138,120 @@ foo 0 NONE A 10.0.0.1 foo 0 NONE A 10.0.0.2 """ -class UpdateTestCase(unittest.TestCase): - def test_to_wire1(self): # type: () -> None - update = dns.update.Update('example') +class UpdateTestCase(unittest.TestCase): + def test_to_wire1(self): # type: () -> None + update = dns.update.Update("example") update.id = 1 - update.present('foo') - update.present('foo', 'a') - update.present('bar', 'a', '10.0.0.5') - update.absent('blaz2') - update.absent('blaz2', 'a') - update.replace('foo', 300, 'a', '10.0.0.1', '10.0.0.2') - update.add('bar', 300, 'a', '10.0.0.3') - update.delete('bar', 'a', '10.0.0.4') - update.delete('blaz', 'a') - update.delete('blaz2') + update.present("foo") + update.present("foo", "a") + update.present("bar", "a", "10.0.0.5") + update.absent("blaz2") + update.absent("blaz2", "a") + update.replace("foo", 300, "a", "10.0.0.1", "10.0.0.2") + update.add("bar", 300, "a", "10.0.0.3") + update.delete("bar", "a", "10.0.0.4") + update.delete("blaz", "a") + update.delete("blaz2") self.assertEqual(update.to_wire(), goodwire) - def test_to_wire2(self): # type: () -> None - update = dns.update.Update('example') + def test_to_wire2(self): # type: () -> None + update = dns.update.Update("example") update.id = 1 - update.present('foo') - update.present('foo', 'a') - update.present('bar', 'a', '10.0.0.5') - update.absent('blaz2') - update.absent('blaz2', 'a') - update.replace('foo', 300, 'a', '10.0.0.1', '10.0.0.2') - update.add('bar', 300, dns.rdata.from_text(1, 1, '10.0.0.3')) - update.delete('bar', 'a', '10.0.0.4') - update.delete('blaz', 'a') - update.delete('blaz2') + update.present("foo") + update.present("foo", "a") + update.present("bar", "a", "10.0.0.5") + update.absent("blaz2") + update.absent("blaz2", "a") + update.replace("foo", 300, "a", "10.0.0.1", "10.0.0.2") + update.add("bar", 300, dns.rdata.from_text(1, 1, "10.0.0.3")) + update.delete("bar", "a", "10.0.0.4") + update.delete("blaz", "a") + update.delete("blaz2") self.assertEqual(update.to_wire(), goodwire) - def test_to_wire3(self): # type: () -> None - update = dns.update.Update('example') + def test_to_wire3(self): # type: () -> None + update = dns.update.Update("example") update.id = 1 - update.present('foo') - update.present('foo', 'a') - update.present('bar', 'a', '10.0.0.5') - update.absent('blaz2') - update.absent('blaz2', 'a') - update.replace('foo', 300, 'a', '10.0.0.1', '10.0.0.2') - update.add('bar', dns.rdataset.from_text(1, 1, 300, '10.0.0.3')) - update.delete('bar', 'a', '10.0.0.4') - update.delete('blaz', 'a') - update.delete('blaz2') + update.present("foo") + update.present("foo", "a") + update.present("bar", "a", "10.0.0.5") + update.absent("blaz2") + update.absent("blaz2", "a") + update.replace("foo", 300, "a", "10.0.0.1", "10.0.0.2") + update.add("bar", dns.rdataset.from_text(1, 1, 300, "10.0.0.3")) + update.delete("bar", "a", "10.0.0.4") + update.delete("blaz", "a") + update.delete("blaz2") self.assertEqual(update.to_wire(), goodwire) - def test_from_text1(self): # type: () -> None + def test_from_text1(self): # type: () -> None update = dns.message.from_text(update_text) self.assertTrue(isinstance(update, dns.update.UpdateMessage)) - w = update.to_wire(origin=dns.name.from_text('example'), - want_shuffle=False) + w = update.to_wire(origin=dns.name.from_text("example"), want_shuffle=False) self.assertEqual(w, goodwire) def test_from_wire(self): - origin = dns.name.from_text('example') + origin = dns.name.from_text("example") u1 = dns.message.from_wire(goodwire, origin=origin) u2 = dns.message.from_text(update_text, origin=origin) self.assertEqual(u1, u2) def test_good_explicit_delete_wire(self): - name = dns.name.from_text('foo.example') + name = dns.name.from_text("foo.example") u = dns.message.from_wire(goodwirenone) self.assertEqual(u.update[0].name, name) self.assertEqual(u.update[0].rdtype, dns.rdatatype.A) self.assertEqual(u.update[0].rdclass, dns.rdataclass.IN) self.assertTrue(u.update[0].deleting) - self.assertEqual(u.update[0][0].address, '1.2.3.4') + self.assertEqual(u.update[0][0].address, "1.2.3.4") def test_none_with_rdata_from_wire(self): def bad(): dns.message.from_wire(badwirenone) + self.assertRaises(dns.exception.FormError, bad) def test_any_with_rdata_from_wire(self): def bad(): dns.message.from_wire(badwireany) + self.assertRaises(dns.exception.FormError, bad) def test_any_any_with_rdata_from_wire(self): def bad(): dns.message.from_wire(badwireanyany) + self.assertRaises(dns.exception.FormError, bad) def test_bad_zone_type_from_wire(self): def bad(): dns.message.from_wire(badwirezonetype) + self.assertRaises(dns.exception.FormError, bad) def test_bad_zone_class_from_wire(self): def bad(): dns.message.from_wire(badwirezoneclass) + self.assertRaises(dns.exception.FormError, bad) def test_bad_zone_multi_from_wire(self): def bad(): dns.message.from_wire(badwirezonemulti) + self.assertRaises(dns.exception.FormError, bad) def test_no_zone_section_from_wire(self): def bad(): dns.message.from_wire(badwirenozone) + self.assertRaises(dns.exception.FormError, bad) def test_TSIG(self): - keyring = dns.tsigkeyring.from_text({ - 'keyname.' : 'NjHwPsMKjdN++dOfE5iAiQ==' - }) - update = dns.update.Update('example.', keyring=keyring) - update.replace('host.example.', 300, 'A', '1.2.3.4') + keyring = dns.tsigkeyring.from_text({"keyname.": "NjHwPsMKjdN++dOfE5iAiQ=="}) + update = dns.update.Update("example.", keyring=keyring) + update.replace("host.example.", 300, "A", "1.2.3.4") wire = update.to_wire() update2 = dns.message.from_wire(wire, keyring) self.assertEqual(update, update2) @@ -262,16 +264,18 @@ class UpdateTestCase(unittest.TestCase): self.assertTrue(update.is_response(r)) def test_making_UpdateSection(self): - self.assertEqual(dns.update.UpdateSection.make(0), - dns.update.UpdateSection.make('ZONE')) + self.assertEqual( + dns.update.UpdateSection.make(0), dns.update.UpdateSection.make("ZONE") + ) with self.assertRaises(ValueError): dns.update.UpdateSection.make(99) def test_setters(self): u = dns.update.UpdateMessage(id=1) - qrrset = dns.rrset.RRset(dns.name.from_text('example'), - dns.rdataclass.IN, dns.rdatatype.SOA) - rrset = dns.rrset.from_text('foo', 300, 'in', 'a', '10.0.0.1') + qrrset = dns.rrset.RRset( + dns.name.from_text("example"), dns.rdataclass.IN, dns.rdatatype.SOA + ) + rrset = dns.rrset.from_text("foo", 300, "in", "a", "10.0.0.1") u.zone = [qrrset] self.assertEqual(u.sections[0], [qrrset]) self.assertEqual(u.sections[1], []) @@ -289,58 +293,53 @@ class UpdateTestCase(unittest.TestCase): self.assertEqual(u.sections[3], []) def test_added_rdataset(self): - u = dns.update.UpdateMessage('example.', id=1) - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1', '10.0.0.2') - u.add('foo', rds) + u = dns.update.UpdateMessage("example.", id=1) + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.1", "10.0.0.2") + u.add("foo", rds) expected = dns.message.from_text(added_text) self.assertEqual(u, expected) def test_replaced_rdataset(self): - u = dns.update.UpdateMessage('example.', id=1) - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1', '10.0.0.2') - u.replace('foo', rds) + u = dns.update.UpdateMessage("example.", id=1) + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.1", "10.0.0.2") + u.replace("foo", rds) expected = dns.message.from_text(replaced_text) self.assertEqual(u, expected) def test_delete_rdataset(self): - u = dns.update.UpdateMessage('example.', id=1) - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1', '10.0.0.2') - u.delete('foo', rds) + u = dns.update.UpdateMessage("example.", id=1) + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.1", "10.0.0.2") + u.delete("foo", rds) expected = dns.message.from_text(deleted_text) self.assertEqual(u, expected) def test_added_rdata(self): - u = dns.update.UpdateMessage('example.', id=1) - rd1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1') - rd2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2') - u.add('foo', 300, rd1) - u.add('foo', 300, rd2) + u = dns.update.UpdateMessage("example.", id=1) + rd1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1") + rd2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2") + u.add("foo", 300, rd1) + u.add("foo", 300, rd2) expected = dns.message.from_text(added_text) self.assertEqual(u, expected) def test_replaced_rdata(self): - u = dns.update.UpdateMessage('example.', id=1) - rd1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1') - rd2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2') - u.replace('foo', 300, rd1) - u.add('foo', 300, rd2) + u = dns.update.UpdateMessage("example.", id=1) + rd1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1") + rd2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2") + u.replace("foo", 300, rd1) + u.add("foo", 300, rd2) expected = dns.message.from_text(replaced_text) self.assertEqual(u, expected) def test_deleted_rdata(self): - u = dns.update.UpdateMessage('example.', id=1) - rd1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1') - rd2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2') - u.delete('foo', rd1) - u.delete('foo', rd2) + u = dns.update.UpdateMessage("example.", id=1) + rd1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1") + rd2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2") + u.delete("foo", rd1) + u.delete("foo", rd2) expected = dns.message.from_text(deleted_text) self.assertEqual(u, expected) -if __name__ == '__main__': + +if __name__ == "__main__": unittest.main() diff --git a/tests/test_wire.py b/tests/test_wire.py index a4b5991..6d9df18 100644 --- a/tests/test_wire.py +++ b/tests/test_wire.py @@ -8,9 +8,8 @@ import dns.name class BinaryTestCase(unittest.TestCase): - def test_basic(self): - wire = bytes.fromhex('0102010203040102') + wire = bytes.fromhex("0102010203040102") p = dns.wire.Parser(wire) self.assertEqual(p.get_uint16(), 0x0102) with p.restrict_to(5): @@ -26,8 +25,8 @@ class BinaryTestCase(unittest.TestCase): def test_name(self): # www.dnspython.org NS IN question - wire = b'\x03www\x09dnspython\x03org\x00\x00\x02\x00\x01' - expected = dns.name.from_text('www.dnspython.org') + wire = b"\x03www\x09dnspython\x03org\x00\x00\x02\x00\x01" + expected = dns.name.from_text("www.dnspython.org") p = dns.wire.Parser(wire) self.assertEqual(p.get_name(), expected) self.assertEqual(p.get_uint16(), 2) @@ -36,18 +35,18 @@ class BinaryTestCase(unittest.TestCase): def test_relativized_name(self): # www.dnspython.org NS IN question - wire = b'\x03www\x09dnspython\x03org\x00\x00\x02\x00\x01' - origin = dns.name.from_text('dnspython.org') - expected = dns.name.from_text('www', None) + wire = b"\x03www\x09dnspython\x03org\x00\x00\x02\x00\x01" + origin = dns.name.from_text("dnspython.org") + expected = dns.name.from_text("www", None) p = dns.wire.Parser(wire) self.assertEqual(p.get_name(origin), expected) self.assertEqual(p.remaining(), 4) def test_compressed_name(self): # www.dnspython.org NS IN question - wire = b'\x09dnspython\x03org\x00\x03www\xc0\x00' - expected1 = dns.name.from_text('dnspython.org') - expected2 = dns.name.from_text('www.dnspython.org') + wire = b"\x09dnspython\x03org\x00\x03www\xc0\x00" + expected1 = dns.name.from_text("dnspython.org") + expected2 = dns.name.from_text("www.dnspython.org") p = dns.wire.Parser(wire) self.assertEqual(p.get_name(), expected1) self.assertEqual(p.get_name(), expected2) @@ -56,7 +55,7 @@ class BinaryTestCase(unittest.TestCase): self.assertEqual(p.current, len(wire)) def test_seek(self): - wire = b'\x09dnspython\x03org\x00' + wire = b"\x09dnspython\x03org\x00" p = dns.wire.Parser(wire) p.seek(10) self.assertEqual(p.get_uint8(), 3) @@ -72,7 +71,7 @@ class BinaryTestCase(unittest.TestCase): p.seek(len(wire) + 1) def test_not_reading_everything_in_restriction(self): - wire = bytes.fromhex('0102010203040102') + wire = bytes.fromhex("0102010203040102") p = dns.wire.Parser(wire) with self.assertRaises(dns.exception.FormError): with p.restrict_to(5): @@ -81,7 +80,7 @@ class BinaryTestCase(unittest.TestCase): # don't read the other 4 bytes def test_restriction_does_not_mask_exception(self): - wire = bytes.fromhex('0102010203040102') + wire = bytes.fromhex("0102010203040102") p = dns.wire.Parser(wire) with self.assertRaises(NotImplementedError): with p.restrict_to(5): diff --git a/tests/test_xfr.py b/tests/test_xfr.py index 3cf4c91..2a739ea 100644 --- a/tests/test_xfr.py +++ b/tests/test_xfr.py @@ -17,13 +17,16 @@ import dns.xfr # those tests. try: from .nanonameserver import Server + _nanonameserver_available = True except ImportError: _nanonameserver_available = False + class Server(object): pass -axfr = '''id 1 + +axfr = """id 1 opcode QUERY rcode NOERROR flags AA @@ -37,9 +40,9 @@ bar.foo 300 IN MX 0 blaz.foo ns1 3600 IN A 10.0.0.1 ns2 3600 IN A 10.0.0.2 @ 3600 IN SOA foo bar 1 2 3 4 5 -''' +""" -axfr1 = '''id 1 +axfr1 = """id 1 opcode QUERY rcode NOERROR flags AA @@ -49,8 +52,8 @@ example. IN AXFR @ 3600 IN SOA foo bar 1 2 3 4 5 @ 3600 IN NS ns1 @ 3600 IN NS ns2 -''' -axfr2 = '''id 1 +""" +axfr2 = """id 1 opcode QUERY rcode NOERROR flags AA @@ -59,7 +62,7 @@ bar.foo 300 IN MX 0 blaz.foo ns1 3600 IN A 10.0.0.1 ns2 3600 IN A 10.0.0.2 @ 3600 IN SOA foo bar 1 2 3 4 5 -''' +""" base = """@ 3600 IN SOA foo bar 1 2 3 4 5 @ 3600 IN NS ns1 @@ -69,7 +72,7 @@ ns1 3600 IN A 10.0.0.1 ns2 3600 IN A 10.0.0.2 """ -axfr_unexpected_origin = '''id 1 +axfr_unexpected_origin = """id 1 opcode QUERY rcode NOERROR flags AA @@ -78,9 +81,9 @@ example. IN AXFR ;ANSWER @ 3600 IN SOA foo bar 1 2 3 4 5 @ 3600 IN SOA foo bar 1 2 3 4 7 -''' +""" -ixfr = '''id 1 +ixfr = """id 1 opcode QUERY rcode NOERROR flags AA @@ -100,9 +103,9 @@ ns3 3600 IN A 10.0.0.3 @ 3600 IN NS ns2 @ 3600 IN SOA foo bar 4 2 3 4 5 @ 3600 IN SOA foo bar 4 2 3 4 5 -''' +""" -compressed_ixfr = '''id 1 +compressed_ixfr = """id 1 opcode QUERY rcode NOERROR flags AA @@ -118,7 +121,7 @@ ns2 3600 IN A 10.0.0.2 ns2 3600 IN A 10.0.0.4 ns3 3600 IN A 10.0.0.3 @ 3600 IN SOA foo bar 4 2 3 4 5 -''' +""" ixfr_expected = """@ 3600 IN SOA foo bar 4 2 3 4 5 @ 3600 IN NS ns1 @@ -127,7 +130,7 @@ ns2 3600 IN A 10.0.0.4 ns3 3600 IN A 10.0.0.3 """ -ixfr_first_message = '''id 1 +ixfr_first_message = """id 1 opcode QUERY rcode NOERROR flags AA @@ -135,34 +138,34 @@ flags AA example. IN IXFR ;ANSWER @ 3600 IN SOA foo bar 4 2 3 4 5 -''' +""" -ixfr_header = '''id 1 +ixfr_header = """id 1 opcode QUERY rcode NOERROR flags AA ;ANSWER -''' +""" ixfr_body = [ - '@ 3600 IN SOA foo bar 1 2 3 4 5', - 'bar.foo 300 IN MX 0 blaz.foo', - 'ns2 3600 IN A 10.0.0.2', - '@ 3600 IN SOA foo bar 2 2 3 4 5', - 'ns2 3600 IN A 10.0.0.4', - '@ 3600 IN SOA foo bar 2 2 3 4 5', - '@ 3600 IN SOA foo bar 3 2 3 4 5', - 'ns3 3600 IN A 10.0.0.3', - '@ 3600 IN SOA foo bar 3 2 3 4 5', - '@ 3600 IN NS ns2', - '@ 3600 IN SOA foo bar 4 2 3 4 5', - '@ 3600 IN SOA foo bar 4 2 3 4 5', + "@ 3600 IN SOA foo bar 1 2 3 4 5", + "bar.foo 300 IN MX 0 blaz.foo", + "ns2 3600 IN A 10.0.0.2", + "@ 3600 IN SOA foo bar 2 2 3 4 5", + "ns2 3600 IN A 10.0.0.4", + "@ 3600 IN SOA foo bar 2 2 3 4 5", + "@ 3600 IN SOA foo bar 3 2 3 4 5", + "ns3 3600 IN A 10.0.0.3", + "@ 3600 IN SOA foo bar 3 2 3 4 5", + "@ 3600 IN NS ns2", + "@ 3600 IN SOA foo bar 4 2 3 4 5", + "@ 3600 IN SOA foo bar 4 2 3 4 5", ] ixfrs = [ixfr_first_message] ixfrs.extend([ixfr_header + l for l in ixfr_body]) -good_empty_ixfr = '''id 1 +good_empty_ixfr = """id 1 opcode QUERY rcode NOERROR flags AA @@ -170,9 +173,9 @@ flags AA example. IN IXFR ;ANSWER @ 3600 IN SOA foo bar 1 2 3 4 5 -''' +""" -retry_tcp_ixfr = '''id 1 +retry_tcp_ixfr = """id 1 opcode QUERY rcode NOERROR flags AA @@ -180,9 +183,9 @@ flags AA example. IN IXFR ;ANSWER @ 3600 IN SOA foo bar 5 2 3 4 5 -''' +""" -bad_empty_ixfr = '''id 1 +bad_empty_ixfr = """id 1 opcode QUERY rcode NOERROR flags AA @@ -191,9 +194,9 @@ example. IN IXFR ;ANSWER @ 3600 IN SOA foo bar 4 2 3 4 5 @ 3600 IN SOA foo bar 4 2 3 4 5 -''' +""" -unexpected_end_ixfr = '''id 1 +unexpected_end_ixfr = """id 1 opcode QUERY rcode NOERROR flags AA @@ -209,9 +212,9 @@ ns2 3600 IN A 10.0.0.2 ns2 3600 IN A 10.0.0.4 ns3 3600 IN A 10.0.0.3 @ 3600 IN SOA foo bar 4 2 3 4 5 -''' +""" -unexpected_end_ixfr_2 = '''id 1 +unexpected_end_ixfr_2 = """id 1 opcode QUERY rcode NOERROR flags AA @@ -223,9 +226,9 @@ example. IN IXFR bar.foo 300 IN MX 0 blaz.foo ns2 3600 IN A 10.0.0.2 @ 3600 IN NS ns2 -''' +""" -bad_serial_ixfr = '''id 1 +bad_serial_ixfr = """id 1 opcode QUERY rcode NOERROR flags AA @@ -241,9 +244,9 @@ ns2 3600 IN A 10.0.0.2 ns2 3600 IN A 10.0.0.4 ns3 3600 IN A 10.0.0.3 @ 3600 IN SOA foo bar 4 2 3 4 5 -''' +""" -ixfr_axfr = '''id 1 +ixfr_axfr = """id 1 opcode QUERY rcode NOERROR flags AA @@ -257,213 +260,209 @@ bar.foo 300 IN MX 0 blaz.foo ns1 3600 IN A 10.0.0.1 ns2 3600 IN A 10.0.0.2 @ 3600 IN SOA foo bar 1 2 3 4 5 -''' +""" + def test_basic_axfr(): - z = dns.versioned.Zone('example.') - m = dns.message.from_text(axfr, origin=z.origin, - one_rr_per_rrset=True) + z = dns.versioned.Zone("example.") + m = dns.message.from_text(axfr, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.AXFR) as xfr: done = xfr.process_message(m) assert done - ez = dns.zone.from_text(base, 'example.') + ez = dns.zone.from_text(base, "example.") assert z == ez + def test_basic_axfr_unversioned(): - z = dns.zone.Zone('example.') - m = dns.message.from_text(axfr, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.Zone("example.") + m = dns.message.from_text(axfr, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.AXFR) as xfr: done = xfr.process_message(m) assert done - ez = dns.zone.from_text(base, 'example.') + ez = dns.zone.from_text(base, "example.") assert z == ez + def test_basic_axfr_two_parts(): - z = dns.versioned.Zone('example.') - m1 = dns.message.from_text(axfr1, origin=z.origin, - one_rr_per_rrset=True) - m2 = dns.message.from_text(axfr2, origin=z.origin, - one_rr_per_rrset=True) + z = dns.versioned.Zone("example.") + m1 = dns.message.from_text(axfr1, origin=z.origin, one_rr_per_rrset=True) + m2 = dns.message.from_text(axfr2, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.AXFR) as xfr: done = xfr.process_message(m1) assert not done done = xfr.process_message(m2) assert done - ez = dns.zone.from_text(base, 'example.') + ez = dns.zone.from_text(base, "example.") assert z == ez + def test_axfr_unexpected_origin(): - z = dns.versioned.Zone('example.') - m = dns.message.from_text(axfr_unexpected_origin, origin=z.origin, - one_rr_per_rrset=True) + z = dns.versioned.Zone("example.") + m = dns.message.from_text( + axfr_unexpected_origin, origin=z.origin, one_rr_per_rrset=True + ) with dns.xfr.Inbound(z, dns.rdatatype.AXFR) as xfr: with pytest.raises(dns.exception.FormError): xfr.process_message(m) + def test_basic_ixfr(): - z = dns.zone.from_text(base, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(ixfr, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(base, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text(ixfr, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1) as xfr: done = xfr.process_message(m) assert done - ez = dns.zone.from_text(ixfr_expected, 'example.') + ez = dns.zone.from_text(ixfr_expected, "example.") assert z == ez + def test_basic_ixfr_unversioned(): - z = dns.zone.from_text(base, 'example.') - m = dns.message.from_text(ixfr, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(base, "example.") + m = dns.message.from_text(ixfr, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1) as xfr: done = xfr.process_message(m) assert done - ez = dns.zone.from_text(ixfr_expected, 'example.') + ez = dns.zone.from_text(ixfr_expected, "example.") assert z == ez + def test_compressed_ixfr(): - z = dns.zone.from_text(base, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(compressed_ixfr, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(base, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text(compressed_ixfr, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1) as xfr: done = xfr.process_message(m) assert done - ez = dns.zone.from_text(ixfr_expected, 'example.') + ez = dns.zone.from_text(ixfr_expected, "example.") assert z == ez + def test_basic_ixfr_many_parts(): - z = dns.zone.from_text(base, 'example.', - zone_factory=dns.versioned.Zone) + z = dns.zone.from_text(base, "example.", zone_factory=dns.versioned.Zone) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1) as xfr: done = False for text in ixfrs: assert not done - m = dns.message.from_text(text, origin=z.origin, - one_rr_per_rrset=True) + m = dns.message.from_text(text, origin=z.origin, one_rr_per_rrset=True) done = xfr.process_message(m) assert done - ez = dns.zone.from_text(ixfr_expected, 'example.') + ez = dns.zone.from_text(ixfr_expected, "example.") assert z == ez + def test_good_empty_ixfr(): - z = dns.zone.from_text(ixfr_expected, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(good_empty_ixfr, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(ixfr_expected, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text(good_empty_ixfr, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1) as xfr: done = xfr.process_message(m) assert done - ez = dns.zone.from_text(ixfr_expected, 'example.') + ez = dns.zone.from_text(ixfr_expected, "example.") assert z == ez + def test_retry_tcp_ixfr(): - z = dns.zone.from_text(ixfr_expected, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(retry_tcp_ixfr, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(ixfr_expected, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text(retry_tcp_ixfr, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1, is_udp=True) as xfr: with pytest.raises(dns.xfr.UseTCP): xfr.process_message(m) + def test_bad_empty_ixfr(): - z = dns.zone.from_text(ixfr_expected, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(bad_empty_ixfr, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(ixfr_expected, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text(bad_empty_ixfr, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=3) as xfr: with pytest.raises(dns.exception.FormError): xfr.process_message(m) + def test_serial_went_backwards_ixfr(): - z = dns.zone.from_text(ixfr_expected, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(bad_empty_ixfr, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(ixfr_expected, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text(bad_empty_ixfr, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=5) as xfr: with pytest.raises(dns.xfr.SerialWentBackwards): xfr.process_message(m) + def test_ixfr_is_axfr(): - z = dns.zone.from_text(base, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(ixfr_axfr, origin=z.origin, - one_rr_per_rrset=True) - with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=0xffffffff) as xfr: + z = dns.zone.from_text(base, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text(ixfr_axfr, origin=z.origin, one_rr_per_rrset=True) + with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=0xFFFFFFFF) as xfr: done = xfr.process_message(m) assert done - ez = dns.zone.from_text(base, 'example.') + ez = dns.zone.from_text(base, "example.") assert z == ez + def test_ixfr_requires_serial(): - z = dns.zone.from_text(base, 'example.', - zone_factory=dns.versioned.Zone) + z = dns.zone.from_text(base, "example.", zone_factory=dns.versioned.Zone) with pytest.raises(ValueError): dns.xfr.Inbound(z, dns.rdatatype.IXFR) + def test_ixfr_unexpected_end_bad_diff_sequence(): # This is where we get the end serial, but haven't seen all of # the expected diffs - z = dns.zone.from_text(base, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(unexpected_end_ixfr, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(base, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text( + unexpected_end_ixfr, origin=z.origin, one_rr_per_rrset=True + ) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1) as xfr: with pytest.raises(dns.exception.FormError): xfr.process_message(m) + def test_udp_ixfr_unexpected_end_just_stops(): # This is where everything looks good, but the IXFR just stops # in the middle. - z = dns.zone.from_text(base, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(unexpected_end_ixfr_2, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(base, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text( + unexpected_end_ixfr_2, origin=z.origin, one_rr_per_rrset=True + ) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1, is_udp=True) as xfr: with pytest.raises(dns.exception.FormError): xfr.process_message(m) + def test_ixfr_bad_serial(): - z = dns.zone.from_text(base, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(bad_serial_ixfr, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(base, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text(bad_serial_ixfr, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1) as xfr: with pytest.raises(dns.exception.FormError): xfr.process_message(m) + def test_no_udp_with_axfr(): - z = dns.versioned.Zone('example.') + z = dns.versioned.Zone("example.") with pytest.raises(ValueError): with dns.xfr.Inbound(z, dns.rdatatype.AXFR, is_udp=True) as xfr: pass -refused = '''id 1 + +refused = """id 1 opcode QUERY rcode REFUSED flags AA ;QUESTION example. IN AXFR -''' +""" -bad_qname = '''id 1 +bad_qname = """id 1 opcode QUERY rcode NOERROR flags AA ;QUESTION not-example. IN IXFR -''' +""" -bad_qtype = '''id 1 +bad_qtype = """id 1 opcode QUERY rcode NOERROR flags AA ;QUESTION example. IN AXFR -''' +""" -soa_not_first = '''id 1 +soa_not_first = """id 1 opcode QUERY rcode NOERROR flags AA @@ -471,9 +470,9 @@ flags AA example. IN IXFR ;ANSWER bar.foo 300 IN MX 0 blaz.foo -''' +""" -soa_not_first_2 = '''id 1 +soa_not_first_2 = """id 1 opcode QUERY rcode NOERROR flags AA @@ -481,9 +480,9 @@ flags AA example. IN IXFR ;ANSWER @ 300 IN MX 0 blaz.foo -''' +""" -no_answer = '''id 1 +no_answer = """id 1 opcode QUERY rcode NOERROR flags AA @@ -491,9 +490,9 @@ flags AA example. IN IXFR ;ADDITIONAL bar.foo 300 IN MX 0 blaz.foo -''' +""" -axfr_answers_after_final_soa = '''id 1 +axfr_answers_after_final_soa = """id 1 opcode QUERY rcode NOERROR flags AA @@ -508,76 +507,70 @@ ns1 3600 IN A 10.0.0.1 ns2 3600 IN A 10.0.0.2 @ 3600 IN SOA foo bar 1 2 3 4 5 ns3 3600 IN A 10.0.0.3 -''' +""" + def test_refused(): - z = dns.zone.from_text(base, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(refused, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(base, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text(refused, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1) as xfr: with pytest.raises(dns.xfr.TransferError): xfr.process_message(m) + def test_bad_qname(): - z = dns.zone.from_text(base, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(bad_qname, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(base, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text(bad_qname, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1) as xfr: with pytest.raises(dns.exception.FormError): xfr.process_message(m) + def test_bad_qtype(): - z = dns.zone.from_text(base, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(bad_qtype, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(base, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text(bad_qtype, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1) as xfr: with pytest.raises(dns.exception.FormError): xfr.process_message(m) + def test_soa_not_first(): - z = dns.zone.from_text(base, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(soa_not_first, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(base, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text(soa_not_first, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1) as xfr: with pytest.raises(dns.exception.FormError): xfr.process_message(m) - m = dns.message.from_text(soa_not_first_2, origin=z.origin, - one_rr_per_rrset=True) + m = dns.message.from_text(soa_not_first_2, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1) as xfr: with pytest.raises(dns.exception.FormError): xfr.process_message(m) + def test_no_answer(): - z = dns.zone.from_text(base, 'example.', - zone_factory=dns.versioned.Zone) - m = dns.message.from_text(no_answer, origin=z.origin, - one_rr_per_rrset=True) + z = dns.zone.from_text(base, "example.", zone_factory=dns.versioned.Zone) + m = dns.message.from_text(no_answer, origin=z.origin, one_rr_per_rrset=True) with dns.xfr.Inbound(z, dns.rdatatype.IXFR, serial=1) as xfr: with pytest.raises(dns.exception.FormError): xfr.process_message(m) + def test_axfr_answers_after_final_soa(): - z = dns.versioned.Zone('example.') - m = dns.message.from_text(axfr_answers_after_final_soa, origin=z.origin, - one_rr_per_rrset=True) + z = dns.versioned.Zone("example.") + m = dns.message.from_text( + axfr_answers_after_final_soa, origin=z.origin, one_rr_per_rrset=True + ) with dns.xfr.Inbound(z, dns.rdatatype.AXFR) as xfr: with pytest.raises(dns.exception.FormError): xfr.process_message(m) -keyring = dns.tsigkeyring.from_text( - { - 'keyname.': 'NjHwPsMKjdN++dOfE5iAiQ==' - } -) -keyname = dns.name.from_text('keyname') +keyring = dns.tsigkeyring.from_text({"keyname.": "NjHwPsMKjdN++dOfE5iAiQ=="}) + +keyname = dns.name.from_text("keyname") + def test_make_query_basic(): - z = dns.versioned.Zone('example.') + z = dns.versioned.Zone("example.") (q, s) = dns.xfr.make_query(z) assert q.question[0].rdtype == dns.rdatatype.AXFR assert s is None @@ -590,7 +583,7 @@ def test_make_query_basic(): assert q.authority[0][0].serial == 10 assert s == 10 with z.writer() as txn: - txn.add('@', 300, dns.rdata.from_text('in', 'soa', '. . 1 2 3 4 5')) + txn.add("@", 300, dns.rdata.from_text("in", "soa", ". . 1 2 3 4 5")) (q, s) = dns.xfr.make_query(z) assert q.question[0].rdtype == dns.rdatatype.IXFR assert q.authority[0].rdtype == dns.rdatatype.SOA @@ -605,16 +598,17 @@ def test_make_query_basic(): def test_make_query_bad_serial(): - z = dns.versioned.Zone('example.') + z = dns.versioned.Zone("example.") with pytest.raises(ValueError): - dns.xfr.make_query(z, serial='hi') + dns.xfr.make_query(z, serial="hi") with pytest.raises(ValueError): dns.xfr.make_query(z, serial=-1) with pytest.raises(ValueError): dns.xfr.make_query(z, serial=4294967296) + def test_extract_serial_from_query(): - z = dns.versioned.Zone('example.') + z = dns.versioned.Zone("example.") (q, s) = dns.xfr.make_query(z) xs = dns.xfr.extract_serial_from_query(q) assert s is None @@ -623,15 +617,14 @@ def test_extract_serial_from_query(): xs = dns.xfr.extract_serial_from_query(q) assert s == 10 assert s == xs - q = dns.message.make_query('example', 'a') + q = dns.message.make_query("example", "a") with pytest.raises(ValueError): dns.xfr.extract_serial_from_query(q) class XFRNanoNameserver(Server): - def __init__(self): - super().__init__(origin=dns.name.from_text('example')) + super().__init__(origin=dns.name.from_text("example")) def handle(self, request): try: @@ -639,45 +632,62 @@ class XFRNanoNameserver(Server): text = ixfr else: text = axfr - r = dns.message.from_text(text, one_rr_per_rrset=True, - origin=self.origin) + r = dns.message.from_text(text, one_rr_per_rrset=True, origin=self.origin) r.id = request.message.id return r except Exception: pass -@pytest.mark.skipif(not _nanonameserver_available, - reason="requires nanonameserver") + +@pytest.mark.skipif(not _nanonameserver_available, reason="requires nanonameserver") def test_sync_inbound_xfr(): with XFRNanoNameserver() as ns: - zone = dns.versioned.Zone('example') - dns.query.inbound_xfr(ns.tcp_address[0], zone, port=ns.tcp_address[1], - udp_mode=dns.query.UDPMode.TRY_FIRST) - dns.query.inbound_xfr(ns.tcp_address[0], zone, port=ns.tcp_address[1], - udp_mode=dns.query.UDPMode.TRY_FIRST) - expected = dns.zone.from_text(ixfr_expected, 'example') + zone = dns.versioned.Zone("example") + dns.query.inbound_xfr( + ns.tcp_address[0], + zone, + port=ns.tcp_address[1], + udp_mode=dns.query.UDPMode.TRY_FIRST, + ) + dns.query.inbound_xfr( + ns.tcp_address[0], + zone, + port=ns.tcp_address[1], + udp_mode=dns.query.UDPMode.TRY_FIRST, + ) + expected = dns.zone.from_text(ixfr_expected, "example") assert zone == expected + async def async_inbound_xfr(): with XFRNanoNameserver() as ns: - zone = dns.versioned.Zone('example') - await dns.asyncquery.inbound_xfr(ns.tcp_address[0], zone, - port=ns.tcp_address[1], - udp_mode=dns.query.UDPMode.TRY_FIRST) - await dns.asyncquery.inbound_xfr(ns.tcp_address[0], zone, - port=ns.tcp_address[1], - udp_mode=dns.query.UDPMode.TRY_FIRST) - expected = dns.zone.from_text(ixfr_expected, 'example') + zone = dns.versioned.Zone("example") + await dns.asyncquery.inbound_xfr( + ns.tcp_address[0], + zone, + port=ns.tcp_address[1], + udp_mode=dns.query.UDPMode.TRY_FIRST, + ) + await dns.asyncquery.inbound_xfr( + ns.tcp_address[0], + zone, + port=ns.tcp_address[1], + udp_mode=dns.query.UDPMode.TRY_FIRST, + ) + expected = dns.zone.from_text(ixfr_expected, "example") assert zone == expected -@pytest.mark.skipif(not _nanonameserver_available, - reason="requires nanonameserver") + +@pytest.mark.skipif(not _nanonameserver_available, reason="requires nanonameserver") def test_asyncio_inbound_xfr(): - dns.asyncbackend.set_default_backend('asyncio') + dns.asyncbackend.set_default_backend("asyncio") + async def run(): await async_inbound_xfr() + asyncio.run(run()) + # # We don't need to do this as it's all generic code, but # just for extra caution we do it for each backend. @@ -686,34 +696,37 @@ def test_asyncio_inbound_xfr(): try: import trio - @pytest.mark.skipif(not _nanonameserver_available, - reason="requires nanonameserver") + @pytest.mark.skipif(not _nanonameserver_available, reason="requires nanonameserver") def test_trio_inbound_xfr(): - dns.asyncbackend.set_default_backend('trio') + dns.asyncbackend.set_default_backend("trio") + async def run(): await async_inbound_xfr() + trio.run(run) + except ImportError: pass try: import curio - @pytest.mark.skipif(not _nanonameserver_available, - reason="requires nanonameserver") + @pytest.mark.skipif(not _nanonameserver_available, reason="requires nanonameserver") def test_curio_inbound_xfr(): - dns.asyncbackend.set_default_backend('curio') + dns.asyncbackend.set_default_backend("curio") + async def run(): await async_inbound_xfr() + curio.run(run) + except ImportError: pass class UDPXFRNanoNameserver(Server): - def __init__(self): - super().__init__(origin=dns.name.from_text('example')) + super().__init__(origin=dns.name.from_text("example")) self.did_truncation = False def handle(self, request): @@ -726,48 +739,66 @@ class UDPXFRNanoNameserver(Server): self.did_truncation = True else: text = axfr - r = dns.message.from_text(text, one_rr_per_rrset=True, - origin=self.origin) + r = dns.message.from_text(text, one_rr_per_rrset=True, origin=self.origin) r.id = request.message.id return r except Exception: pass -@pytest.mark.skipif(not _nanonameserver_available, - reason="requires nanonameserver") + +@pytest.mark.skipif(not _nanonameserver_available, reason="requires nanonameserver") def test_sync_retry_tcp_inbound_xfr(): with UDPXFRNanoNameserver() as ns: - zone = dns.versioned.Zone('example') - dns.query.inbound_xfr(ns.tcp_address[0], zone, port=ns.tcp_address[1], - udp_mode=dns.query.UDPMode.TRY_FIRST) - dns.query.inbound_xfr(ns.tcp_address[0], zone, port=ns.tcp_address[1], - udp_mode=dns.query.UDPMode.TRY_FIRST) - expected = dns.zone.from_text(ixfr_expected, 'example') + zone = dns.versioned.Zone("example") + dns.query.inbound_xfr( + ns.tcp_address[0], + zone, + port=ns.tcp_address[1], + udp_mode=dns.query.UDPMode.TRY_FIRST, + ) + dns.query.inbound_xfr( + ns.tcp_address[0], + zone, + port=ns.tcp_address[1], + udp_mode=dns.query.UDPMode.TRY_FIRST, + ) + expected = dns.zone.from_text(ixfr_expected, "example") assert zone == expected + async def udp_async_inbound_xfr(): with UDPXFRNanoNameserver() as ns: - zone = dns.versioned.Zone('example') - await dns.asyncquery.inbound_xfr(ns.tcp_address[0], zone, - port=ns.tcp_address[1], - udp_mode=dns.query.UDPMode.TRY_FIRST) - await dns.asyncquery.inbound_xfr(ns.tcp_address[0], zone, - port=ns.tcp_address[1], - udp_mode=dns.query.UDPMode.TRY_FIRST) - expected = dns.zone.from_text(ixfr_expected, 'example') + zone = dns.versioned.Zone("example") + await dns.asyncquery.inbound_xfr( + ns.tcp_address[0], + zone, + port=ns.tcp_address[1], + udp_mode=dns.query.UDPMode.TRY_FIRST, + ) + await dns.asyncquery.inbound_xfr( + ns.tcp_address[0], + zone, + port=ns.tcp_address[1], + udp_mode=dns.query.UDPMode.TRY_FIRST, + ) + expected = dns.zone.from_text(ixfr_expected, "example") assert zone == expected -@pytest.mark.skipif(not _nanonameserver_available, - reason="requires nanonameserver") + +@pytest.mark.skipif(not _nanonameserver_available, reason="requires nanonameserver") def test_asyncio_retry_tcp_inbound_xfr(): - dns.asyncbackend.set_default_backend('asyncio') + dns.asyncbackend.set_default_backend("asyncio") + async def run(): await udp_async_inbound_xfr() + try: runner = asyncio.run except AttributeError: + def old_runner(awaitable): loop = asyncio.get_event_loop() return loop.run_until_complete(awaitable) + runner = old_runner runner(run()) diff --git a/tests/test_zone.py b/tests/test_zone.py index b7046b2..de7ec01 100644 --- a/tests/test_zone.py +++ b/tests/test_zone.py @@ -124,7 +124,9 @@ $ORIGIN example. """ include_text = """$INCLUDE "%s" -""" % here("example") +""" % here( + "example" +) bad_directive_text = """$FOO bar $ORIGIN example. @@ -243,24 +245,28 @@ web a 10.0.0.4 _keep_output = True + def _rdata_sort(a): return (a[0], a[2].rdclass, a[2].to_text()) + def add_rdataset(msg, name, rds): - rrset = msg.get_rrset(msg.answer, name, rds.rdclass, rds.rdtype, - create=True, force_unique=True) + rrset = msg.get_rrset( + msg.answer, name, rds.rdclass, rds.rdtype, create=True, force_unique=True + ) for rd in rds: rrset.add(rd, ttl=rds.ttl) + def make_xfr(zone): - q = dns.message.make_query(zone.origin, 'AXFR') + q = dns.message.make_query(zone.origin, "AXFR") msg = dns.message.make_response(q) if zone.relativize: msg.origin = zone.origin soa_name = dns.name.empty else: soa_name = zone.origin - soa = zone.find_rdataset(soa_name, 'SOA') + soa = zone.find_rdataset(soa_name, "SOA") add_rdataset(msg, soa_name, soa) for (name, rds) in zone.iterate_rdatasets(): if rds.rdtype == dns.rdatatype.SOA: @@ -269,48 +275,48 @@ def make_xfr(zone): add_rdataset(msg, soa_name, soa) return [msg] + def compare_files(test_name, a_name, b_name): - with open(a_name, 'r') as a: - with open(b_name, 'r') as b: - differences = list(difflib.unified_diff(a.readlines(), - b.readlines())) + with open(a_name, "r") as a: + with open(b_name, "r") as b: + differences = list(difflib.unified_diff(a.readlines(), b.readlines())) if len(differences) == 0: return True else: - print(f'{test_name} differences:') + print(f"{test_name} differences:") sys.stdout.writelines(differences) return False -class ZoneTestCase(unittest.TestCase): +class ZoneTestCase(unittest.TestCase): def testFromFile1(self): - z = dns.zone.from_file(here('example'), 'example') + z = dns.zone.from_file(here("example"), "example") ok = False try: - z.to_file(here('example1.out'), nl=b'\x0a') - ok = compare_files('testFromFile1', - here('example1.out'), - here('example1.good')) + z.to_file(here("example1.out"), nl=b"\x0a") + ok = compare_files( + "testFromFile1", here("example1.out"), here("example1.good") + ) finally: if not _keep_output: - os.unlink(here('example1.out')) + os.unlink(here("example1.out")) self.assertTrue(ok) def testFromFile2(self): - z = dns.zone.from_file(here('example'), 'example', relativize=False) + z = dns.zone.from_file(here("example"), "example", relativize=False) ok = False try: - z.to_file(here('example2.out'), relativize=False, nl=b'\x0a') - ok = compare_files('testFromFile2', - here('example2.out'), - here('example2.good')) + z.to_file(here("example2.out"), relativize=False, nl=b"\x0a") + ok = compare_files( + "testFromFile2", here("example2.out"), here("example2.good") + ) finally: if not _keep_output: - os.unlink(here('example2.out')) + os.unlink(here("example2.out")) self.assertTrue(ok) def testToFileTextualStream(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) + z = dns.zone.from_text(example_text, "example.", relativize=True) f = StringIO() z.to_file(f) out = f.getvalue() @@ -318,105 +324,111 @@ class ZoneTestCase(unittest.TestCase): self.assertEqual(out, example_text_output) def testToFileBinaryStream(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) + z = dns.zone.from_text(example_text, "example.", relativize=True) f = BytesIO() - z.to_file(f, nl=b'\n') + z.to_file(f, nl=b"\n") out = f.getvalue() f.close() self.assertEqual(out, example_text_output.encode()) def testToFileTextual(self): - z = dns.zone.from_file(here('example'), 'example') + z = dns.zone.from_file(here("example"), "example") try: - f = open(here('example3-textual.out'), 'w') + f = open(here("example3-textual.out"), "w") z.to_file(f) f.close() - ok = compare_files('testToFileTextual', - here('example3-textual.out'), - here('example3.good')) + ok = compare_files( + "testToFileTextual", here("example3-textual.out"), here("example3.good") + ) finally: if not _keep_output: - os.unlink(here('example3-textual.out')) + os.unlink(here("example3-textual.out")) self.assertTrue(ok) def testToFileBinary(self): - z = dns.zone.from_file(here('example'), 'example') + z = dns.zone.from_file(here("example"), "example") try: - f = open(here('example3-binary.out'), 'wb') + f = open(here("example3-binary.out"), "wb") z.to_file(f) f.close() - ok = compare_files('testToFileBinary', - here('example3-binary.out'), - here('example3.good')) + ok = compare_files( + "testToFileBinary", here("example3-binary.out"), here("example3.good") + ) finally: if not _keep_output: - os.unlink(here('example3-binary.out')) + os.unlink(here("example3-binary.out")) self.assertTrue(ok) def testToFileFilename(self): - z = dns.zone.from_file(here('example'), 'example') + z = dns.zone.from_file(here("example"), "example") try: - z.to_file(here('example3-filename.out')) - ok = compare_files('testToFileFilename', - here('example3-filename.out'), - here('example3.good')) + z.to_file(here("example3-filename.out")) + ok = compare_files( + "testToFileFilename", + here("example3-filename.out"), + here("example3.good"), + ) finally: if not _keep_output: - os.unlink(here('example3-filename.out')) + os.unlink(here("example3-filename.out")) self.assertTrue(ok) def testToText(self): - z = dns.zone.from_file(here('example'), 'example') + z = dns.zone.from_file(here("example"), "example") ok = False try: - text_zone = z.to_text(nl='\x0a') - f = open(here('example3.out'), 'w') + text_zone = z.to_text(nl="\x0a") + f = open(here("example3.out"), "w") f.write(text_zone) f.close() - ok = compare_files('testToText', - here('example3.out'), - here('example3.good')) + ok = compare_files( + "testToText", here("example3.out"), here("example3.good") + ) finally: if not _keep_output: - os.unlink(here('example3.out')) + os.unlink(here("example3.out")) self.assertTrue(ok) def testToFileTextualWithOrigin(self): - z = dns.zone.from_file(here('example'), 'example') + z = dns.zone.from_file(here("example"), "example") try: - f = open(here('example4-textual.out'), 'w') + f = open(here("example4-textual.out"), "w") z.to_file(f, want_origin=True) f.close() - ok = compare_files('testToFileTextualWithOrigin', - here('example4-textual.out'), - here('example4.good')) + ok = compare_files( + "testToFileTextualWithOrigin", + here("example4-textual.out"), + here("example4.good"), + ) finally: if not _keep_output: - os.unlink(here('example4-textual.out')) + os.unlink(here("example4-textual.out")) self.assertTrue(ok) def testToFileBinaryWithOrigin(self): - z = dns.zone.from_file(here('example'), 'example') + z = dns.zone.from_file(here("example"), "example") try: - f = open(here('example4-binary.out'), 'wb') + f = open(here("example4-binary.out"), "wb") z.to_file(f, want_origin=True) f.close() - ok = compare_files('testToFileBinaryWithOrigin', - here('example4-binary.out'), - here('example4.good')) + ok = compare_files( + "testToFileBinaryWithOrigin", + here("example4-binary.out"), + here("example4.good"), + ) finally: if not _keep_output: - os.unlink(here('example4-binary.out')) + os.unlink(here("example4-binary.out")) self.assertTrue(ok) def testFromText(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) + z = dns.zone.from_text(example_text, "example.", relativize=True) f = StringIO() names = list(z.nodes.keys()) names.sort() for n in names: f.write(z[n].to_text(n)) - f.write('\n') + f.write("\n") self.assertEqual(f.getvalue(), example_text_output) def testTorture1(self): @@ -426,8 +438,8 @@ class ZoneTestCase(unittest.TestCase): # and then back out, and see if we get equal rdatas. # f = BytesIO() - o = dns.name.from_text('example.') - z = dns.zone.from_file(here('example'), o) + o = dns.name.from_text("example.") + z = dns.zone.from_file(here("example"), o) for node in z.values(): for rds in node: for rd in rds: @@ -435,437 +447,507 @@ class ZoneTestCase(unittest.TestCase): f.truncate() rd.to_wire(f, origin=o) wire = f.getvalue() - rd2 = dns.rdata.from_wire(rds.rdclass, rds.rdtype, - wire, 0, len(wire), - origin=o) + rd2 = dns.rdata.from_wire( + rds.rdclass, rds.rdtype, wire, 0, len(wire), origin=o + ) self.assertEqual(rd, rd2) def testEqual(self): - z1 = dns.zone.from_text(example_text, 'example.', relativize=True) - z2 = dns.zone.from_text(example_text_output, 'example.', - relativize=True) + z1 = dns.zone.from_text(example_text, "example.", relativize=True) + z2 = dns.zone.from_text(example_text_output, "example.", relativize=True) self.assertEqual(z1, z2) def testNotEqual1(self): - z1 = dns.zone.from_text(example_text, 'example.', relativize=True) - z2 = dns.zone.from_text(something_quite_similar, 'example.', - relativize=True) + z1 = dns.zone.from_text(example_text, "example.", relativize=True) + z2 = dns.zone.from_text(something_quite_similar, "example.", relativize=True) self.assertNotEqual(z1, z2) def testNotEqual2(self): - z1 = dns.zone.from_text(example_text, 'example.', relativize=True) - z2 = dns.zone.from_text(something_different, 'example.', - relativize=True) + z1 = dns.zone.from_text(example_text, "example.", relativize=True) + z2 = dns.zone.from_text(something_different, "example.", relativize=True) self.assertNotEqual(z1, z2) def testNotEqual3(self): - z1 = dns.zone.from_text(example_text, 'example.', relativize=True) - z2 = dns.zone.from_text(something_different, 'example2.', - relativize=True) + z1 = dns.zone.from_text(example_text, "example.", relativize=True) + z2 = dns.zone.from_text(something_different, "example2.", relativize=True) self.assertNotEqual(z1, z2) def testFindRdataset1(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - rds = z.find_rdataset('@', 'soa') - exrds = dns.rdataset.from_text('IN', 'SOA', 300, 'foo bar 1 2 3 4 5') + z = dns.zone.from_text(example_text, "example.", relativize=True) + rds = z.find_rdataset("@", "soa") + exrds = dns.rdataset.from_text("IN", "SOA", 300, "foo bar 1 2 3 4 5") self.assertEqual(rds, exrds) def testFindRdataset2(self): def bad(): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - z.find_rdataset('@', 'loc') + z = dns.zone.from_text(example_text, "example.", relativize=True) + z.find_rdataset("@", "loc") + self.assertRaises(KeyError, bad) def testFindRRset1(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - rrs = z.find_rrset('@', 'soa') - exrrs = dns.rrset.from_text('@', 300, 'IN', 'SOA', 'foo bar 1 2 3 4 5') + z = dns.zone.from_text(example_text, "example.", relativize=True) + rrs = z.find_rrset("@", "soa") + exrrs = dns.rrset.from_text("@", 300, "IN", "SOA", "foo bar 1 2 3 4 5") self.assertEqual(rrs, exrrs) def testFindRRset2(self): def bad(): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - z.find_rrset('@', 'loc') + z = dns.zone.from_text(example_text, "example.", relativize=True) + z.find_rrset("@", "loc") + self.assertRaises(KeyError, bad) def testGetRdataset1(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - rds = z.get_rdataset('@', 'soa') - exrds = dns.rdataset.from_text('IN', 'SOA', 300, 'foo bar 1 2 3 4 5') + z = dns.zone.from_text(example_text, "example.", relativize=True) + rds = z.get_rdataset("@", "soa") + exrds = dns.rdataset.from_text("IN", "SOA", 300, "foo bar 1 2 3 4 5") self.assertEqual(rds, exrds) def testGetRdataset2(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - rds = z.get_rdataset('@', 'loc') + z = dns.zone.from_text(example_text, "example.", relativize=True) + rds = z.get_rdataset("@", "loc") self.assertTrue(rds is None) def testGetRdatasetWithRelativeNameFromAbsoluteZone(self): - z = dns.zone.from_text(example_text, 'example.', relativize=False) - rds = z.get_rdataset(dns.name.empty, 'soa') + z = dns.zone.from_text(example_text, "example.", relativize=False) + rds = z.get_rdataset(dns.name.empty, "soa") self.assertIsNotNone(rds) - exrds = dns.rdataset.from_text('IN', 'SOA', 300, 'foo.example. bar.example. 1 2 3 4 5') + exrds = dns.rdataset.from_text( + "IN", "SOA", 300, "foo.example. bar.example. 1 2 3 4 5" + ) self.assertEqual(rds, exrds) def testGetRRset1(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - rrs = z.get_rrset('@', 'soa') - exrrs = dns.rrset.from_text('@', 300, 'IN', 'SOA', 'foo bar 1 2 3 4 5') + z = dns.zone.from_text(example_text, "example.", relativize=True) + rrs = z.get_rrset("@", "soa") + exrrs = dns.rrset.from_text("@", 300, "IN", "SOA", "foo bar 1 2 3 4 5") self.assertEqual(rrs, exrrs) def testGetRRset2(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - rrs = z.get_rrset('@', 'loc') + z = dns.zone.from_text(example_text, "example.", relativize=True) + rrs = z.get_rrset("@", "loc") self.assertTrue(rrs is None) def testReplaceRdataset1(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - rdataset = dns.rdataset.from_text('in', 'ns', 300, 'ns3', 'ns4') - z.replace_rdataset('@', rdataset) - rds = z.get_rdataset('@', 'ns') + z = dns.zone.from_text(example_text, "example.", relativize=True) + rdataset = dns.rdataset.from_text("in", "ns", 300, "ns3", "ns4") + z.replace_rdataset("@", rdataset) + rds = z.get_rdataset("@", "ns") self.assertTrue(rds is rdataset) def testReplaceRdataset2(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - rdataset = dns.rdataset.from_text('in', 'txt', 300, '"foo"') - z.replace_rdataset('@', rdataset) - rds = z.get_rdataset('@', 'txt') + z = dns.zone.from_text(example_text, "example.", relativize=True) + rdataset = dns.rdataset.from_text("in", "txt", 300, '"foo"') + z.replace_rdataset("@", rdataset) + rds = z.get_rdataset("@", "txt") self.assertTrue(rds is rdataset) def testDeleteRdataset1(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - z.delete_rdataset('@', 'ns') - rds = z.get_rdataset('@', 'ns') + z = dns.zone.from_text(example_text, "example.", relativize=True) + z.delete_rdataset("@", "ns") + rds = z.get_rdataset("@", "ns") self.assertTrue(rds is None) def testDeleteRdataset2(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - z.delete_rdataset('ns1', 'a') - node = z.get_node('ns1') + z = dns.zone.from_text(example_text, "example.", relativize=True) + z.delete_rdataset("ns1", "a") + node = z.get_node("ns1") self.assertTrue(node is None) def testNodeFindRdataset1(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - node = z['@'] + z = dns.zone.from_text(example_text, "example.", relativize=True) + node = z["@"] rds = node.find_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA) - exrds = dns.rdataset.from_text('IN', 'SOA', 300, 'foo bar 1 2 3 4 5') + exrds = dns.rdataset.from_text("IN", "SOA", 300, "foo bar 1 2 3 4 5") self.assertEqual(rds, exrds) def testNodeFindRdataset2(self): def bad(): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - node = z['@'] + z = dns.zone.from_text(example_text, "example.", relativize=True) + node = z["@"] node.find_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC) + self.assertRaises(KeyError, bad) def testNodeFindRdataset3(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - node = z['@'] - rds = node.find_rdataset(dns.rdataclass.IN, dns.rdatatype.RRSIG, - dns.rdatatype.A, create=True) + z = dns.zone.from_text(example_text, "example.", relativize=True) + node = z["@"] + rds = node.find_rdataset( + dns.rdataclass.IN, dns.rdatatype.RRSIG, dns.rdatatype.A, create=True + ) self.assertEqual(rds.rdclass, dns.rdataclass.IN) self.assertEqual(rds.rdtype, dns.rdatatype.RRSIG) self.assertEqual(rds.covers, dns.rdatatype.A) def testNodeGetRdataset1(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - node = z['@'] + z = dns.zone.from_text(example_text, "example.", relativize=True) + node = z["@"] rds = node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA) - exrds = dns.rdataset.from_text('IN', 'SOA', 300, 'foo bar 1 2 3 4 5') + exrds = dns.rdataset.from_text("IN", "SOA", 300, "foo bar 1 2 3 4 5") self.assertEqual(rds, exrds) def testNodeGetRdataset2(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - node = z['@'] + z = dns.zone.from_text(example_text, "example.", relativize=True) + node = z["@"] rds = node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC) self.assertTrue(rds is None) def testNodeDeleteRdataset1(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - node = z['@'] + z = dns.zone.from_text(example_text, "example.", relativize=True) + node = z["@"] node.delete_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA) rds = node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA) self.assertTrue(rds is None) def testNodeDeleteRdataset2(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - node = z['@'] + z = dns.zone.from_text(example_text, "example.", relativize=True) + node = z["@"] node.delete_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC) rds = node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC) self.assertTrue(rds is None) def testIterateNodes(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) + z = dns.zone.from_text(example_text, "example.", relativize=True) count = 0 for n in z: count += 1 self.assertEqual(count, 4) def testIterateRdatasets(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - ns = [n for n, r in z.iterate_rdatasets('A')] + z = dns.zone.from_text(example_text, "example.", relativize=True) + ns = [n for n, r in z.iterate_rdatasets("A")] ns.sort() - self.assertEqual(ns, [dns.name.from_text('ns1', None), - dns.name.from_text('ns2', None)]) + self.assertEqual( + ns, [dns.name.from_text("ns1", None), dns.name.from_text("ns2", None)] + ) def testIterateAllRdatasets(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) + z = dns.zone.from_text(example_text, "example.", relativize=True) ns = [n for n, r in z.iterate_rdatasets()] ns.sort() - self.assertEqual(ns, [dns.name.from_text('@', None), - dns.name.from_text('@', None), - dns.name.from_text('bar.foo', None), - dns.name.from_text('ns1', None), - dns.name.from_text('ns2', None)]) + self.assertEqual( + ns, + [ + dns.name.from_text("@", None), + dns.name.from_text("@", None), + dns.name.from_text("bar.foo", None), + dns.name.from_text("ns1", None), + dns.name.from_text("ns2", None), + ], + ) def testIterateRdatas(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - l = list(z.iterate_rdatas('A')) + z = dns.zone.from_text(example_text, "example.", relativize=True) + l = list(z.iterate_rdatas("A")) l.sort() - exl = [(dns.name.from_text('ns1', None), + exl = [ + ( + dns.name.from_text("ns1", None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1')), - (dns.name.from_text('ns2', None), + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1"), + ), + ( + dns.name.from_text("ns2", None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2'))] + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2"), + ), + ] self.assertEqual(l, exl) def testIterateAllRdatas(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) + z = dns.zone.from_text(example_text, "example.", relativize=True) l = list(z.iterate_rdatas()) l.sort(key=_rdata_sort) - exl = [(dns.name.from_text('@', None), + exl = [ + ( + dns.name.from_text("@", None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns1')), - (dns.name.from_text('@', None), + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns1"), + ), + ( + dns.name.from_text("@", None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, - 'ns2')), - (dns.name.from_text('@', None), + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS, "ns2"), + ), + ( + dns.name.from_text("@", None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, - 'foo bar 1 2 3 4 5')), - (dns.name.from_text('bar.foo', None), + dns.rdata.from_text( + dns.rdataclass.IN, dns.rdatatype.SOA, "foo bar 1 2 3 4 5" + ), + ), + ( + dns.name.from_text("bar.foo", None), 300, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, - '0 blaz.foo')), - (dns.name.from_text('ns1', None), + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.MX, "0 blaz.foo"), + ), + ( + dns.name.from_text("ns1", None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.1')), - (dns.name.from_text('ns2', None), + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.1"), + ), + ( + dns.name.from_text("ns2", None), 3600, - dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, - '10.0.0.2'))] + dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "10.0.0.2"), + ), + ] exl.sort(key=_rdata_sort) self.assertEqual(l, exl) def testNodeGetSetDel(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) + z = dns.zone.from_text(example_text, "example.", relativize=True) n = z.node_factory() - rds = dns.rdataset.from_text('IN', 'A', 300, '10.0.0.1') + rds = dns.rdataset.from_text("IN", "A", 300, "10.0.0.1") n.replace_rdataset(rds) - z['foo'] = n - self.assertTrue(z.find_rdataset('foo', 'A') is rds) - self.assertEqual(z['foo'], n) - self.assertEqual(z.get('foo'), n) - del z['foo'] - self.assertEqual(z.get('foo'), None) + z["foo"] = n + self.assertTrue(z.find_rdataset("foo", "A") is rds) + self.assertEqual(z["foo"], n) + self.assertEqual(z.get("foo"), n) + del z["foo"] + self.assertEqual(z.get("foo"), None) with self.assertRaises(KeyError): z[123] = n with self.assertRaises(KeyError): - z['foo.'] = n + z["foo."] = n with self.assertRaises(KeyError): - bn = z.find_node('bar') - bn = z.find_node('bar', True) + bn = z.find_node("bar") + bn = z.find_node("bar", True) self.assertTrue(isinstance(bn, dns.node.Node)) # The next two tests pass by not raising KeyError - z.delete_node('foo') - z.delete_node('bar') + z.delete_node("foo") + z.delete_node("bar") def testBadReplacement(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - rds = dns.rdataset.from_text('CH', 'TXT', 300, 'hi') + z = dns.zone.from_text(example_text, "example.", relativize=True) + rds = dns.rdataset.from_text("CH", "TXT", 300, "hi") + def bad(): - z.replace_rdataset('foo', rds) + z.replace_rdataset("foo", rds) + self.assertRaises(ValueError, bad) def testTTLs(self): - z = dns.zone.from_text(ttl_example_text, 'example.', relativize=True) - n = z['@'] # type: dns.node.Node - rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA)) + z = dns.zone.from_text(ttl_example_text, "example.", relativize=True) + n = z["@"] # type: dns.node.Node + rds = cast( + dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA) + ) self.assertEqual(rds.ttl, 3600) - n = z['ns1'] - rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)) + n = z["ns1"] + rds = cast( + dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A) + ) self.assertEqual(rds.ttl, 86401) - n = z['ns2'] - rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)) + n = z["ns2"] + rds = cast( + dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A) + ) self.assertEqual(rds.ttl, 694861) def testTTLFromSOA(self): - z = dns.zone.from_text(ttl_from_soa_text, 'example.', relativize=True) - n = z['@'] - rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA)) + z = dns.zone.from_text(ttl_from_soa_text, "example.", relativize=True) + n = z["@"] + rds = cast( + dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA) + ) self.assertEqual(rds.ttl, 3600) soa_rd = rds[0] - n = z['ns1'] - rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)) + n = z["ns1"] + rds = cast( + dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A) + ) self.assertEqual(rds.ttl, 694861) - n = z['ns2'] - rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)) + n = z["ns2"] + rds = cast( + dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A) + ) self.assertEqual(rds.ttl, soa_rd.minimum) def testTTLFromLast(self): - z = dns.zone.from_text(ttl_from_last_text, 'example.', check_origin=False) - n = z['@'] - rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.NS)) + z = dns.zone.from_text(ttl_from_last_text, "example.", check_origin=False) + n = z["@"] + rds = cast( + dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.NS) + ) self.assertEqual(rds.ttl, 3600) - n = z['ns1'] - rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)) + n = z["ns1"] + rds = cast( + dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A) + ) self.assertEqual(rds.ttl, 3600) - n = z['ns2'] - rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)) + n = z["ns2"] + rds = cast( + dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A) + ) self.assertEqual(rds.ttl, 694861) def testNoTTL(self): def bad(): - dns.zone.from_text(no_ttl_text, 'example.', check_origin=False) + dns.zone.from_text(no_ttl_text, "example.", check_origin=False) + self.assertRaises(dns.exception.SyntaxError, bad) def testNoSOA(self): def bad(): - dns.zone.from_text(no_soa_text, 'example.', relativize=True) + dns.zone.from_text(no_soa_text, "example.", relativize=True) + self.assertRaises(dns.zone.NoSOA, bad) def testNoNS(self): def bad(): - dns.zone.from_text(no_ns_text, 'example.', relativize=True) + dns.zone.from_text(no_ns_text, "example.", relativize=True) + self.assertRaises(dns.zone.NoNS, bad) def testInclude(self): - z1 = dns.zone.from_text(include_text, 'example.', relativize=True, - allow_include=True) - z2 = dns.zone.from_file(here('example'), 'example.', relativize=True) + z1 = dns.zone.from_text( + include_text, "example.", relativize=True, allow_include=True + ) + z2 = dns.zone.from_file(here("example"), "example.", relativize=True) self.assertEqual(z1, z2) def testBadDirective(self): def bad(): - dns.zone.from_text(bad_directive_text, 'example.', relativize=True) + dns.zone.from_text(bad_directive_text, "example.", relativize=True) + self.assertRaises(dns.exception.SyntaxError, bad) def testFirstRRStartsWithWhitespace(self): # no name is specified, so default to the initial origin - z = dns.zone.from_text(' 300 IN A 10.0.0.1', origin='example.', - check_origin=False) - n = z['@'] - rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)) + z = dns.zone.from_text( + " 300 IN A 10.0.0.1", origin="example.", check_origin=False + ) + n = z["@"] + rds = cast( + dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A) + ) self.assertEqual(rds.ttl, 300) def testZoneOrigin(self): - z = dns.zone.Zone('example.') - self.assertEqual(z.origin, dns.name.from_text('example.')) + z = dns.zone.Zone("example.") + self.assertEqual(z.origin, dns.name.from_text("example.")) + def bad1(): - o = dns.name.from_text('example', None) + o = dns.name.from_text("example", None) dns.zone.Zone(o) + self.assertRaises(ValueError, bad1) + def bad2(): dns.zone.Zone(cast(str, 1.0)) + self.assertRaises(ValueError, bad2) def testZoneOriginNone(self): dns.zone.Zone(cast(str, None)) def testZoneFromXFR(self): - z1_abs = dns.zone.from_text(example_text, 'example.', relativize=False) + z1_abs = dns.zone.from_text(example_text, "example.", relativize=False) z2_abs = dns.zone.from_xfr(make_xfr(z1_abs), relativize=False) self.assertEqual(z1_abs, z2_abs) - z1_rel = dns.zone.from_text(example_text, 'example.', relativize=True) + z1_rel = dns.zone.from_text(example_text, "example.", relativize=True) z2_rel = dns.zone.from_xfr(make_xfr(z1_rel), relativize=True) self.assertEqual(z1_rel, z2_rel) def testCodec2003(self): - z = dns.zone.from_text(codec_text, 'example.', relativize=True) - n2003 = dns.name.from_text('xn--knigsgsschen-lcb0w', None) - n2008 = dns.name.from_text('xn--knigsgchen-b4a3dun', None) + z = dns.zone.from_text(codec_text, "example.", relativize=True) + n2003 = dns.name.from_text("xn--knigsgsschen-lcb0w", None) + n2008 = dns.name.from_text("xn--knigsgchen-b4a3dun", None) self.assertTrue(n2003 in z) self.assertFalse(n2008 in z) - rrs = z.find_rrset(n2003, 'NS') + rrs = z.find_rrset(n2003, "NS") self.assertEqual(rrs[0].target, n2003) - @unittest.skipUnless(dns.name.have_idna_2008, - 'Python idna cannot be imported; no IDNA2008') + @unittest.skipUnless( + dns.name.have_idna_2008, "Python idna cannot be imported; no IDNA2008" + ) def testCodec2008(self): - z = dns.zone.from_text(codec_text, 'example.', relativize=True, - idna_codec=dns.name.IDNA_2008) - n2003 = dns.name.from_text('xn--knigsgsschen-lcb0w', None) - n2008 = dns.name.from_text('xn--knigsgchen-b4a3dun', None) + z = dns.zone.from_text( + codec_text, "example.", relativize=True, idna_codec=dns.name.IDNA_2008 + ) + n2003 = dns.name.from_text("xn--knigsgsschen-lcb0w", None) + n2008 = dns.name.from_text("xn--knigsgchen-b4a3dun", None) self.assertFalse(n2003 in z) self.assertTrue(n2008 in z) - rrs = z.find_rrset(n2008, 'NS') + rrs = z.find_rrset(n2008, "NS") self.assertEqual(rrs[0].target, n2008) def testZoneMiscCases(self): # test that leading whitespace followed by EOL is treated like # a blank line, and that out-of-zone names are dropped. - z1 = dns.zone.from_text(misc_cases_input, 'example.') - z2 = dns.zone.from_text(misc_cases_expected, 'example.') + z1 = dns.zone.from_text(misc_cases_input, "example.") + z2 = dns.zone.from_text(misc_cases_expected, "example.") self.assertEqual(z1, z2) def testUnknownOrigin(self): def bad(): - dns.zone.from_text('foo 300 in a 10.0.0.1') + dns.zone.from_text("foo 300 in a 10.0.0.1") + self.assertRaises(dns.zone.UnknownOrigin, bad) def testBadClass(self): def bad(): - dns.zone.from_text('foo 300 ch txt hi', 'example.') + dns.zone.from_text("foo 300 ch txt hi", "example.") + self.assertRaises(dns.exception.SyntaxError, bad) def testUnknownRdatatype(self): def bad(): - dns.zone.from_text('foo 300 BOGUSTYPE hi', 'example.') + dns.zone.from_text("foo 300 BOGUSTYPE hi", "example.") + self.assertRaises(dns.exception.SyntaxError, bad) def testDangling(self): def bad1(): - dns.zone.from_text('foo', 'example.') + dns.zone.from_text("foo", "example.") + self.assertRaises(dns.exception.SyntaxError, bad1) + def bad2(): - dns.zone.from_text('foo 300', 'example.') + dns.zone.from_text("foo 300", "example.") + self.assertRaises(dns.exception.SyntaxError, bad2) + def bad3(): - dns.zone.from_text('foo 300 in', 'example.') + dns.zone.from_text("foo 300 in", "example.") + self.assertRaises(dns.exception.SyntaxError, bad3) + def bad4(): - dns.zone.from_text('foo 300 in a', 'example.') + dns.zone.from_text("foo 300 in a", "example.") + self.assertRaises(dns.exception.SyntaxError, bad4) + def bad5(): - dns.zone.from_text('$TTL', 'example.') + dns.zone.from_text("$TTL", "example.") + self.assertRaises(dns.exception.SyntaxError, bad5) + def bad6(): - dns.zone.from_text('$ORIGIN', 'example.') + dns.zone.from_text("$ORIGIN", "example.") + self.assertRaises(dns.exception.SyntaxError, bad6) def testUseLastTTL(self): - z = dns.zone.from_text(last_ttl_input, 'example.') - rds = z.find_rdataset('foo', 'A') + z = dns.zone.from_text(last_ttl_input, "example.") + rds = z.find_rdataset("foo", "A") self.assertEqual(rds.ttl, 300) def testDollarOriginSetsZoneOriginIfUnknown(self): z = dns.zone.from_text(origin_sets_input) - self.assertEqual(z.origin, dns.name.from_text('example')) + self.assertEqual(z.origin, dns.name.from_text("example")) def testValidateNameRelativizesNameInZone(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) - self.assertEqual(z._validate_name('foo.bar.example.'), - dns.name.from_text('foo.bar', None)) + z = dns.zone.from_text(example_text, "example.", relativize=True) + self.assertEqual( + z._validate_name("foo.bar.example."), dns.name.from_text("foo.bar", None) + ) def testComments(self): - z = dns.zone.from_text(example_comments_text, 'example.', - relativize=True) + z = dns.zone.from_text(example_comments_text, "example.", relativize=True) f = StringIO() z.to_file(f, want_comments=True) out = f.getvalue() @@ -873,22 +955,21 @@ class ZoneTestCase(unittest.TestCase): self.assertEqual(out, example_comments_text_output) def testUncomparable(self): - z = dns.zone.from_text(example_comments_text, 'example.', - relativize=True) - self.assertFalse(z == 'a') + z = dns.zone.from_text(example_comments_text, "example.", relativize=True) + self.assertFalse(z == "a") def testUnsorted(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True) + z = dns.zone.from_text(example_text, "example.", relativize=True) f = StringIO() z.to_file(f, sorted=False) out = f.getvalue() f.close() - z2 = dns.zone.from_text(out, 'example.', relativize=True) + z2 = dns.zone.from_text(out, "example.", relativize=True) self.assertEqual(z, z2) def testNodeReplaceRdatasetConvertsRRsets(self): node = dns.node.Node() - rrs = dns.rrset.from_text('foo', 300, 'in', 'a', '10.0.0.1') + rrs = dns.rrset.from_text("foo", 300, "in", "a", "10.0.0.1") node.replace_rdataset(rrs) rds = node.find_rdataset(dns.rdataclass.IN, dns.rdatatype.A) self.assertEqual(rds, rrs) @@ -896,219 +977,223 @@ class ZoneTestCase(unittest.TestCase): self.assertFalse(isinstance(rds, dns.rrset.RRset)) def testCnameAndOtherDataAddOther(self): - z = dns.zone.from_text(example_cname, 'example.', relativize=True) - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1') - z.replace_rdataset('web', rds) - z.replace_rdataset('web2', rds.copy()) - n = z.find_node('web') + z = dns.zone.from_text(example_cname, "example.", relativize=True) + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.1") + z.replace_rdataset("web", rds) + z.replace_rdataset("web2", rds.copy()) + n = z.find_node("web") self.assertEqual(len(n.rdatasets), 3) - self.assertEqual(n.find_rdataset(dns.rdataclass.IN, dns.rdatatype.A), - rds) - self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, - dns.rdatatype.NSEC)) - self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, - dns.rdatatype.RRSIG, - dns.rdatatype.NSEC)) - n = z.find_node('web2') + self.assertEqual(n.find_rdataset(dns.rdataclass.IN, dns.rdatatype.A), rds) + self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.NSEC)) + self.assertIsNotNone( + n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.RRSIG, dns.rdatatype.NSEC) + ) + n = z.find_node("web2") self.assertEqual(len(n.rdatasets), 3) - self.assertEqual(n.find_rdataset(dns.rdataclass.IN, dns.rdatatype.A), - rds) - self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, - dns.rdatatype.NSEC3)) - self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, - dns.rdatatype.RRSIG, - dns.rdatatype.NSEC3)) + self.assertEqual(n.find_rdataset(dns.rdataclass.IN, dns.rdatatype.A), rds) + self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.NSEC3)) + self.assertIsNotNone( + n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.RRSIG, dns.rdatatype.NSEC3) + ) def testCnameAndOtherDataAddCname(self): - z = dns.zone.from_text(example_other_data, 'example.', relativize=True) - rds = dns.rdataset.from_text('in', 'cname', 300, 'www') - z.replace_rdataset('web', rds) - n = z.find_node('web') + z = dns.zone.from_text(example_other_data, "example.", relativize=True) + rds = dns.rdataset.from_text("in", "cname", 300, "www") + z.replace_rdataset("web", rds) + n = z.find_node("web") self.assertEqual(len(n.rdatasets), 3) - self.assertEqual(n.find_rdataset(dns.rdataclass.IN, - dns.rdatatype.CNAME), - rds) - self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, - dns.rdatatype.NSEC)) - self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, - dns.rdatatype.RRSIG, - dns.rdatatype.NSEC)) + self.assertEqual(n.find_rdataset(dns.rdataclass.IN, dns.rdatatype.CNAME), rds) + self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.NSEC)) + self.assertIsNotNone( + n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.RRSIG, dns.rdatatype.NSEC) + ) def testCnameAndOtherDataInZonefile(self): with self.assertRaises(dns.zonefile.CNAMEAndOtherData): - dns.zone.from_text(example_cname_and_other_data, 'example.', - relativize=True) + dns.zone.from_text( + example_cname_and_other_data, "example.", relativize=True + ) def testNameInZoneWithStr(self): - z = dns.zone.from_text(example_text, 'example.', relativize=False) - self.assertTrue('ns1.example.' in z) - self.assertTrue('bar.foo.example.' in z) + z = dns.zone.from_text(example_text, "example.", relativize=False) + self.assertTrue("ns1.example." in z) + self.assertTrue("bar.foo.example." in z) def testNameInZoneWhereNameIsNotValid(self): - z = dns.zone.from_text(example_text, 'example.', relativize=False) + z = dns.zone.from_text(example_text, "example.", relativize=False) with self.assertRaises(KeyError): self.assertTrue(1 in z) class VersionedZoneTestCase(unittest.TestCase): def testUseTransaction(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True, - zone_factory=dns.versioned.Zone) + z = dns.zone.from_text( + example_text, "example.", relativize=True, zone_factory=dns.versioned.Zone + ) with self.assertRaises(dns.versioned.UseTransaction): - z.find_node('not_there', True) + z.find_node("not_there", True) with self.assertRaises(dns.versioned.UseTransaction): - z.delete_node('not_there') + z.delete_node("not_there") with self.assertRaises(dns.versioned.UseTransaction): - z.find_rdataset('not_there', 'a', create=True) + z.find_rdataset("not_there", "a", create=True) with self.assertRaises(dns.versioned.UseTransaction): - z.get_rdataset('not_there', 'a', create=True) + z.get_rdataset("not_there", "a", create=True) with self.assertRaises(dns.versioned.UseTransaction): - z.delete_rdataset('not_there', 'a') + z.delete_rdataset("not_there", "a") with self.assertRaises(dns.versioned.UseTransaction): - z.replace_rdataset('not_there', None) + z.replace_rdataset("not_there", None) def testImmutableNodes(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True, - zone_factory=dns.versioned.Zone) - node = z.find_node('@') + z = dns.zone.from_text( + example_text, "example.", relativize=True, zone_factory=dns.versioned.Zone + ) + node = z.find_node("@") with self.assertRaises(TypeError): - node.find_rdataset(dns.rdataclass.IN, dns.rdatatype.RP, - create=True) + node.find_rdataset(dns.rdataclass.IN, dns.rdatatype.RP, create=True) with self.assertRaises(TypeError): - node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.RP, - create=True) + node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.RP, create=True) with self.assertRaises(TypeError): node.delete_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA) with self.assertRaises(TypeError): node.replace_rdataset(None) def testSelectDefaultPruningPolicy(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True, - zone_factory=dns.versioned.Zone) + z = dns.zone.from_text( + example_text, "example.", relativize=True, zone_factory=dns.versioned.Zone + ) z.set_pruning_policy(None) self.assertEqual(z._pruning_policy, z._default_pruning_policy) def testSetAlternatePruningPolicyInConstructor(self): def never_prune(version): return False - z = dns.versioned.Zone('example', pruning_policy=never_prune) + + z = dns.versioned.Zone("example", pruning_policy=never_prune) self.assertEqual(z._pruning_policy, never_prune) def testCannotSpecifyBothSerialAndVersionIdToReader(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True, - zone_factory=dns.versioned.Zone) + z = dns.zone.from_text( + example_text, "example.", relativize=True, zone_factory=dns.versioned.Zone + ) with self.assertRaises(ValueError): z.reader(1, 1) def testUnknownVersion(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True, - zone_factory=dns.versioned.Zone) + z = dns.zone.from_text( + example_text, "example.", relativize=True, zone_factory=dns.versioned.Zone + ) with self.assertRaises(KeyError): z.reader(99999) def testUnknownSerial(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True, - zone_factory=dns.versioned.Zone) + z = dns.zone.from_text( + example_text, "example.", relativize=True, zone_factory=dns.versioned.Zone + ) with self.assertRaises(KeyError): z.reader(serial=99999) def testNoRelativizeReader(self): - z = dns.zone.from_text(example_text, 'example.', relativize=False, - zone_factory=dns.versioned.Zone) + z = dns.zone.from_text( + example_text, "example.", relativize=False, zone_factory=dns.versioned.Zone + ) with z.reader(serial=1) as txn: - rds = txn.get('example.', 'soa') + rds = txn.get("example.", "soa") self.assertEqual(rds[0].serial, 1) def testNoRelativizeReaderOriginInText(self): - z = dns.zone.from_text(example_text, relativize=False, - zone_factory=dns.versioned.Zone) + z = dns.zone.from_text( + example_text, relativize=False, zone_factory=dns.versioned.Zone + ) with z.reader(serial=1) as txn: - rds = txn.get('example.', 'soa') + rds = txn.get("example.", "soa") self.assertEqual(rds[0].serial, 1) def testNoRelativizeReaderAbsoluteGet(self): - z = dns.zone.from_text(example_text, 'example.', relativize=False, - zone_factory=dns.versioned.Zone) + z = dns.zone.from_text( + example_text, "example.", relativize=False, zone_factory=dns.versioned.Zone + ) with z.reader(serial=1) as txn: - rds = txn.get(dns.name.empty, 'soa') + rds = txn.get(dns.name.empty, "soa") self.assertEqual(rds[0].serial, 1) def testCnameAndOtherDataAddOther(self): - z = dns.zone.from_text(example_cname, 'example.', relativize=True, - zone_factory=dns.versioned.Zone) - rds = dns.rdataset.from_text('in', 'a', 300, '10.0.0.1') + z = dns.zone.from_text( + example_cname, "example.", relativize=True, zone_factory=dns.versioned.Zone + ) + rds = dns.rdataset.from_text("in", "a", 300, "10.0.0.1") with z.writer() as txn: - txn.replace('web', rds) - txn.replace('web2', rds.copy()) - n = z.find_node('web') + txn.replace("web", rds) + txn.replace("web2", rds.copy()) + n = z.find_node("web") self.assertEqual(len(n.rdatasets), 3) - self.assertEqual(n.find_rdataset(dns.rdataclass.IN, dns.rdatatype.A), - rds) - self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, - dns.rdatatype.NSEC)) - self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, - dns.rdatatype.RRSIG, - dns.rdatatype.NSEC)) - n = z.find_node('web2') + self.assertEqual(n.find_rdataset(dns.rdataclass.IN, dns.rdatatype.A), rds) + self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.NSEC)) + self.assertIsNotNone( + n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.RRSIG, dns.rdatatype.NSEC) + ) + n = z.find_node("web2") self.assertEqual(len(n.rdatasets), 3) - self.assertEqual(n.find_rdataset(dns.rdataclass.IN, dns.rdatatype.A), - rds) - self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, - dns.rdatatype.NSEC3)) - self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, - dns.rdatatype.RRSIG, - dns.rdatatype.NSEC3)) + self.assertEqual(n.find_rdataset(dns.rdataclass.IN, dns.rdatatype.A), rds) + self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.NSEC3)) + self.assertIsNotNone( + n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.RRSIG, dns.rdatatype.NSEC3) + ) def testCnameAndOtherDataAddCname(self): - z = dns.zone.from_text(example_other_data, 'example.', relativize=True, - zone_factory=dns.versioned.Zone) - rds = dns.rdataset.from_text('in', 'cname', 300, 'www') + z = dns.zone.from_text( + example_other_data, + "example.", + relativize=True, + zone_factory=dns.versioned.Zone, + ) + rds = dns.rdataset.from_text("in", "cname", 300, "www") with z.writer() as txn: - txn.replace('web', rds) - n = z.find_node('web') + txn.replace("web", rds) + n = z.find_node("web") self.assertEqual(len(n.rdatasets), 3) - self.assertEqual(n.find_rdataset(dns.rdataclass.IN, - dns.rdatatype.CNAME), - rds) - self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, - dns.rdatatype.NSEC)) - self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, - dns.rdatatype.RRSIG, - dns.rdatatype.NSEC)) + self.assertEqual(n.find_rdataset(dns.rdataclass.IN, dns.rdatatype.CNAME), rds) + self.assertIsNotNone(n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.NSEC)) + self.assertIsNotNone( + n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.RRSIG, dns.rdatatype.NSEC) + ) def testGetSoa(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True, - zone_factory=dns.versioned.Zone) + z = dns.zone.from_text( + example_text, "example.", relativize=True, zone_factory=dns.versioned.Zone + ) soa = z.get_soa() self.assertTrue(soa.rdtype, dns.rdatatype.SOA) self.assertEqual(soa.serial, 1) def testGetSoaTxn(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True, - zone_factory=dns.versioned.Zone) + z = dns.zone.from_text( + example_text, "example.", relativize=True, zone_factory=dns.versioned.Zone + ) with z.reader(serial=1) as txn: soa = z.get_soa(txn) self.assertTrue(soa.rdtype, dns.rdatatype.SOA) self.assertEqual(soa.serial, 1) def testGetSoaEmptyZone(self): - z = dns.zone.Zone('example.') + z = dns.zone.Zone("example.") with self.assertRaises(dns.zone.NoSOA): soa = z.get_soa() def testGetRdataset1(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True, - zone_factory=dns.versioned.Zone) - rds = z.get_rdataset('@', 'soa') - exrds = dns.rdataset.from_text('IN', 'SOA', 300, 'foo bar 1 2 3 4 5') + z = dns.zone.from_text( + example_text, "example.", relativize=True, zone_factory=dns.versioned.Zone + ) + rds = z.get_rdataset("@", "soa") + exrds = dns.rdataset.from_text("IN", "SOA", 300, "foo bar 1 2 3 4 5") self.assertEqual(rds, exrds) def testGetRdataset2(self): - z = dns.zone.from_text(example_text, 'example.', relativize=True, - zone_factory=dns.versioned.Zone) - rds = z.get_rdataset('@', 'loc') + z = dns.zone.from_text( + example_text, "example.", relativize=True, zone_factory=dns.versioned.Zone + ) + rds = z.get_rdataset("@", "loc") self.assertTrue(rds is None) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/tests/test_zonedigest.py b/tests/test_zonedigest.py index d94be24..bb3f174 100644 --- a/tests/test_zonedigest.py +++ b/tests/test_zonedigest.py @@ -8,10 +8,12 @@ import dns.rdata import dns.rrset import dns.zone + class ZoneDigestTestCase(unittest.TestCase): # Examples from RFC 8976, fixed per errata. - simple_example = textwrap.dedent(''' + simple_example = textwrap.dedent( + """ example. 86400 IN SOA ns1 admin 2018031900 ( 1800 900 604800 86400 ) 86400 IN NS ns1 @@ -25,9 +27,11 @@ class ZoneDigestTestCase(unittest.TestCase): 777f98b8e730044c ) ns1 3600 IN A 203.0.113.63 ns2 3600 IN AAAA 2001:db8::63 - ''') + """ + ) - complex_example = textwrap.dedent(''' + complex_example = textwrap.dedent( + """ example. 86400 IN SOA ns1 admin 2018031900 ( 1800 900 604800 86400 ) 86400 IN NS ns1 @@ -62,9 +66,11 @@ class ZoneDigestTestCase(unittest.TestCase): 6f77656420627574 2069676e6f726564 2e20616c6c6f7765 ) - ''') + """ + ) - multiple_digests_example = textwrap.dedent(''' + multiple_digests_example = textwrap.dedent( + """ example. 86400 IN SOA ns1 admin 2018031900 ( 1800 900 604800 86400 ) example. 86400 IN NS ns1.example. @@ -98,36 +104,34 @@ class ZoneDigestTestCase(unittest.TestCase): ns1.example. 3600 IN A 203.0.113.63 ns2.example. 86400 IN TXT "This example has multiple digests" NS2.EXAMPLE. 3600 IN AAAA 2001:db8::63 - ''') + """ + ) def _get_zonemd(self, zone): - return zone.get_rdataset(zone.origin, 'ZONEMD') + return zone.get_rdataset(zone.origin, "ZONEMD") def test_zonemd_simple(self): - zone = dns.zone.from_text(self.simple_example, origin='example') + zone = dns.zone.from_text(self.simple_example, origin="example") zone.verify_digest() zonemd = self._get_zonemd(zone) - self.assertEqual(zonemd[0], - zone.compute_digest(zonemd[0].hash_algorithm)) + self.assertEqual(zonemd[0], zone.compute_digest(zonemd[0].hash_algorithm)) def test_zonemd_simple_absolute(self): - zone = dns.zone.from_text(self.simple_example, origin='example', - relativize=False) + zone = dns.zone.from_text( + self.simple_example, origin="example", relativize=False + ) zone.verify_digest() zonemd = self._get_zonemd(zone) - self.assertEqual(zonemd[0], - zone.compute_digest(zonemd[0].hash_algorithm)) + self.assertEqual(zonemd[0], zone.compute_digest(zonemd[0].hash_algorithm)) def test_zonemd_complex(self): - zone = dns.zone.from_text(self.complex_example, origin='example') + zone = dns.zone.from_text(self.complex_example, origin="example") zone.verify_digest() zonemd = self._get_zonemd(zone) - self.assertEqual(zonemd[0], - zone.compute_digest(zonemd[0].hash_algorithm)) + self.assertEqual(zonemd[0], zone.compute_digest(zonemd[0].hash_algorithm)) def test_zonemd_multiple_digests(self): - zone = dns.zone.from_text(self.multiple_digests_example, - origin='example') + zone = dns.zone.from_text(self.multiple_digests_example, origin="example") zone.verify_digest() zonemd = self._get_zonemd(zone) @@ -140,54 +144,56 @@ class ZoneDigestTestCase(unittest.TestCase): zone.verify_digest(rr) def test_zonemd_no_digest(self): - zone = dns.zone.from_text(self.simple_example, origin='example') - zone.delete_rdataset(dns.name.empty, 'ZONEMD') + zone = dns.zone.from_text(self.simple_example, origin="example") + zone.delete_rdataset(dns.name.empty, "ZONEMD") with self.assertRaises(dns.zone.NoDigest): zone.verify_digest() - sha384_hash = 'ab' * 48 - sha512_hash = 'ab' * 64 + sha384_hash = "ab" * 48 + sha512_hash = "ab" * 64 def test_zonemd_parse_rdata(self): - dns.rdata.from_text('IN', 'ZONEMD', '100 1 1 ' + self.sha384_hash) - dns.rdata.from_text('IN', 'ZONEMD', '100 1 2 ' + self.sha512_hash) - dns.rdata.from_text('IN', 'ZONEMD', '100 100 1 ' + self.sha384_hash) - dns.rdata.from_text('IN', 'ZONEMD', '100 1 100 abcd') + dns.rdata.from_text("IN", "ZONEMD", "100 1 1 " + self.sha384_hash) + dns.rdata.from_text("IN", "ZONEMD", "100 1 2 " + self.sha512_hash) + dns.rdata.from_text("IN", "ZONEMD", "100 100 1 " + self.sha384_hash) + dns.rdata.from_text("IN", "ZONEMD", "100 1 100 abcd") def test_zonemd_unknown_scheme(self): - zone = dns.zone.from_text(self.simple_example, origin='example') + zone = dns.zone.from_text(self.simple_example, origin="example") with self.assertRaises(dns.zone.UnsupportedDigestScheme): zone.compute_digest(dns.zone.DigestHashAlgorithm.SHA384, 2) def test_zonemd_unknown_hash_algorithm(self): - zone = dns.zone.from_text(self.simple_example, origin='example') + zone = dns.zone.from_text(self.simple_example, origin="example") with self.assertRaises(dns.zone.UnsupportedDigestHashAlgorithm): zone.compute_digest(5) def test_zonemd_invalid_digest_length(self): with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('IN', 'ZONEMD', '100 1 2 ' + self.sha384_hash) + dns.rdata.from_text("IN", "ZONEMD", "100 1 2 " + self.sha384_hash) with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('IN', 'ZONEMD', '100 2 1 ' + self.sha512_hash) + dns.rdata.from_text("IN", "ZONEMD", "100 2 1 " + self.sha512_hash) def test_zonemd_parse_rdata_reserved(self): with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('IN', 'ZONEMD', '100 0 1 ' + self.sha384_hash) + dns.rdata.from_text("IN", "ZONEMD", "100 0 1 " + self.sha384_hash) with self.assertRaises(dns.exception.SyntaxError): - dns.rdata.from_text('IN', 'ZONEMD', '100 1 0 ' + self.sha384_hash) + dns.rdata.from_text("IN", "ZONEMD", "100 1 0 " + self.sha384_hash) - sorting_zone = textwrap.dedent(''' + sorting_zone = textwrap.dedent( + """ @ 86400 IN SOA ns1 admin 2018031900 ( 1800 900 604800 86400 ) 86400 IN NS ns1 86400 IN NS ns2 86400 IN RP n1.example. a. 86400 IN RP n1. b. - ''') - + """ + ) + def test_relative_zone_sorting(self): - z1 = dns.zone.from_text(self.sorting_zone, 'example.', relativize=True) - z2 = dns.zone.from_text(self.sorting_zone, 'example.', relativize=False) + z1 = dns.zone.from_text(self.sorting_zone, "example.", relativize=True) + z2 = dns.zone.from_text(self.sorting_zone, "example.", relativize=False) zmd1 = z1.compute_digest(dns.zone.DigestHashAlgorithm.SHA384) zmd2 = z2.compute_digest(dns.zone.DigestHashAlgorithm.SHA384) self.assertEqual(zmd1, zmd2) diff --git a/tests/ttxt_module.py b/tests/ttxt_module.py index c66131b..0886dde 100644 --- a/tests/ttxt_module.py +++ b/tests/ttxt_module.py @@ -1,4 +1,5 @@ import dns.rdtypes.txtbase + class TTXT(dns.rdtypes.txtbase.TXTBase): """Test TXT-like record""" diff --git a/tests/utest.py b/tests/utest.py index 20f8e18..9f0667e 100644 --- a/tests/utest.py +++ b/tests/utest.py @@ -2,12 +2,12 @@ import os.path import sys import unittest -if __name__ == '__main__': - sys.path.insert(0, os.path.realpath('..')) +if __name__ == "__main__": + sys.path.insert(0, os.path.realpath("..")) if len(sys.argv) > 1: pattern = sys.argv[1] else: - pattern = 'test*.py' - suites = unittest.defaultTestLoader.discover('.', pattern) + pattern = "test*.py" + suites = unittest.defaultTestLoader.discover(".", pattern) if not unittest.TextTestRunner(verbosity=2).run(suites).wasSuccessful(): sys.exit(1) diff --git a/tests/util.py b/tests/util.py index e8c1363..df9ab44 100644 --- a/tests/util.py +++ b/tests/util.py @@ -19,9 +19,11 @@ import enum import inspect import os.path + def here(filename): return os.path.join(os.path.dirname(__file__), filename) + def enumerate_module(module, super_class): """Yield module attributes which are subclasses of given class""" for attr_name in dir(module): @@ -29,12 +31,13 @@ def enumerate_module(module, super_class): if inspect.isclass(attr) and issubclass(attr, super_class): yield attr + def check_enum_exports(module, eq_callback, only=None): """Make sure module exports all mnemonics from enums""" for attr in enumerate_module(module, enum.Enum): if only is not None and attr not in only: - #print('SKIP', attr) + # print('SKIP', attr) continue for flag, value in attr.__members__.items(): - #print(module, flag, value) + # print(module, flag, value) eq_callback(getattr(module, flag), value) |