increase test coverage for various things

diff --git a/tests/test_name.py b/tests/test_name.py
index 6fc2fd31cc4f07cdbcc11aaed4205a5fec54d8d5..389017588120195d9e179734a8889d53694fe5fd 100644 (file)
--- a/tests/test_name.py
+++ b/tests/test_name.py
@@ -440,6 +440,18 @@ class NameTestCase(unittest.TestCase):
         v = n.to_wire()
         self.assertEqual(v, b'\x03FOO\x03bar\x00')
 
+    def testToWireRelativeNameWithOrigin(self):
+        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')
+
+    def testToWireRelativeNameWithoutOrigin(self):
+        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)
@@ -779,6 +791,18 @@ class NameTestCase(unittest.TestCase):
             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.')
+
+    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')
+
     def testReverseIPv4(self):
         e = dns.name.from_text('1.0.0.127.in-addr.arpa.')
         n = dns.reversename.from_address('127.0.0.1')

diff --git a/tests/test_namedict.py b/tests/test_namedict.py
index eb66aaebfd033cf9366aa783191cb2d930c77995..51344fe229dd5a578663a2050d6c352202b7e845 100644 (file)
--- a/tests/test_namedict.py
+++ b/tests/test_namedict.py
@@ -100,5 +100,25 @@ class NameTestCase(unittest.TestCase):
         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.')
+        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.')
+        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.')
+        del self.ndict[n]
+        self.assertEqual(self.ndict.max_depth, 2)
+        self.assertEqual(self.ndict.get(n), None)
+
 if __name__ == '__main__':
     unittest.main()

diff --git a/tests/test_ntoaaton.py b/tests/test_ntoaaton.py
index ba6cc30c311d1737aedd3f6d90ee4f53203971b1..e1d8a15ec41843ccd74721301ab209311f729762 100644 (file)
--- a/tests/test_ntoaaton.py
+++ b/tests/test_ntoaaton.py
@@ -71,6 +71,11 @@ class NtoAAtoNTestCase(unittest.TestCase):
             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')
+        self.assertRaises(dns.exception.SyntaxError, bad)
+
     def test_aton6(self):
         a = aton6('::')
         self.assertEqual(a, b'\x00' * 16)
@@ -159,14 +164,21 @@ class NtoAAtoNTestCase(unittest.TestCase):
 
     def test_bad_ntoa1(self):
         def bad():
-            ntoa6('')
+            ntoa6(b'')
         self.assertRaises(ValueError, bad)
 
     def test_bad_ntoa2(self):
         def bad():
-            ntoa6('\x00' * 17)
+            ntoa6(b'\x00' * 17)
         self.assertRaises(ValueError, bad)
 
+    def test_bad_ntoa3(self):
+        def bad():
+            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'),
@@ -226,6 +238,11 @@ class NtoAAtoNTestCase(unittest.TestCase):
         self.assertFalse(dns.inet.is_multicast(t5))
         self.assertTrue(dns.inet.is_multicast(t6))
 
+    def test_is_multicast_bad_input(self):
+        def bad():
+            dns.inet.is_multicast('hello world')
+        self.assertRaises(ValueError, bad)
+
     def test_ignore_scope(self):
         t1 = 'fe80::1%lo0'
         t2 = 'fe80::1'
@@ -243,5 +260,20 @@ class NtoAAtoNTestCase(unittest.TestCase):
             aton6(t1, True)
         self.assertRaises(dns.exception.SyntaxError, bad)
 
+    def test_ptontop(self):
+        for (af, a) in [(dns.inet.AF_INET, '1.2.3.4'),
+                        (dns.inet.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)]:
+            self.assertEqual(dns.inet.is_address(t), e)
+
 if __name__ == '__main__':
     unittest.main()

diff --git a/tests/test_rdataset.py b/tests/test_rdataset.py
index abc08415ac241df4e6ed0c24314fbf2ef9aa45b0..4d132f9d0fe37ad28519f602f3e96dffb3a4bfb1 100644 (file)
--- a/tests/test_rdataset.py
+++ b/tests/test_rdataset.py
@@ -24,5 +24,12 @@ class RdatasetTestCase(unittest.TestCase):
                                          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'])
+        r2 = r1.copy()
+        self.assertFalse(r1 is r2)
+        self.assertTrue(r1 == r2)
+
 if __name__ == '__main__':
     unittest.main()

diff --git a/tests/test_rrset.py b/tests/test_rrset.py
index 12eac3ff0bfcb06bc0b8a38a58bfe1c3c4b2f47b..e8211dbe243c3d92a281ba16636ff2ba2b53dc64 100644 (file)
--- a/tests/test_rrset.py
+++ b/tests/test_rrset.py
@@ -70,5 +70,49 @@ class RRsetTestCase(unittest.TestCase):
                                       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'])
+        r2 = r1.copy()
+        self.assertFalse(r1 is r2)
+        self.assertTrue(r1 == r2)
+
+    def testMatch1(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))
+
+    def testMatch2(self):
+        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.match(r1.name, dns.rdataclass.IN,
+                                 dns.rdatatype.A, dns.rdatatype.NONE,
+                                 dns.rdataclass.NONE))
+
+    def testNoMatch1(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.match(n, dns.rdataclass.IN,
+                                  dns.rdatatype.A, dns.rdatatype.NONE,
+                                  dns.rdataclass.ANY))
+
+    def testNoMatch2(self):
+        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.match(r1.name, dns.rdataclass.IN,
+                                  dns.rdatatype.A, dns.rdatatype.NONE,
+                                  dns.rdataclass.ANY))
+
+    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'])
+        self.assertEqual(r1.to_rdataset(), r2)
+
 if __name__ == '__main__':
     unittest.main()

diff --git a/tests/test_update.py b/tests/test_update.py
index b2c4767de4a6bb1789dc579e5a3a6f8c78a2471f..41b3b8d1cac82798bc9285fb11ad37e256ad9a26 100644 (file)
--- a/tests/test_update.py
+++ b/tests/test_update.py
@@ -21,6 +21,7 @@ import binascii
 import dns.update
 import dns.rdata
 import dns.rdataset
+import dns.tsigkeyring
 
 goodhex = '0001 2800 0001 0005 0007 0000' \
           '076578616d706c6500 0006 0001' \
@@ -113,5 +114,15 @@ class UpdateTestCase(unittest.TestCase):
                            want_shuffle=False)
         self.assertEqual(w, goodwire)
 
+    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')
+        wire = update.to_wire()
+        update2 = dns.message.from_wire(wire, keyring)
+        self.assertEqual(update, update2)
+
 if __name__ == '__main__':
     unittest.main()