test cleanups and more coverage

diff --git a/tests/test_zone.py b/tests/test_zone.py
index 9857f80514086c0c783e53532d5add129094290c..a301cb25026de74e8f9c2b8c5b9bc79ec4c480f6 100644 (file)
--- a/tests/test_zone.py
+++ b/tests/test_zone.py
@@ -233,7 +233,7 @@ def compare_files(test_name, a_name, b_name):
 
 class ZoneTestCase(unittest.TestCase):
 
-    def testFromFile1(self): # type: () -> None
+    def testFromFile1(self):
         z = dns.zone.from_file(here('example'), 'example')
         ok = False
         try:
@@ -246,7 +246,7 @@ class ZoneTestCase(unittest.TestCase):
                 os.unlink(here('example1.out'))
         self.assertTrue(ok)
 
-    def testFromFile2(self): # type: () -> None
+    def testFromFile2(self):
         z = dns.zone.from_file(here('example'), 'example', relativize=False)
         ok = False
         try:
@@ -259,7 +259,7 @@ class ZoneTestCase(unittest.TestCase):
                 os.unlink(here('example2.out'))
         self.assertTrue(ok)
 
-    def testToFileTextualStream(self): # type: () -> None
+    def testToFileTextualStream(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
         f = StringIO()
         z.to_file(f)
@@ -267,7 +267,7 @@ class ZoneTestCase(unittest.TestCase):
         f.close()
         self.assertEqual(out, example_text_output)
 
-    def testToFileBinaryStream(self): # type: () -> None
+    def testToFileBinaryStream(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
         f = BytesIO()
         z.to_file(f, nl=b'\n')
@@ -275,7 +275,7 @@ class ZoneTestCase(unittest.TestCase):
         f.close()
         self.assertEqual(out, example_text_output.encode())
 
-    def testToFileTextual(self): # type: () -> None
+    def testToFileTextual(self):
         z = dns.zone.from_file(here('example'), 'example')
         try:
             f = open(here('example3-textual.out'), 'w')
@@ -289,7 +289,7 @@ class ZoneTestCase(unittest.TestCase):
                 os.unlink(here('example3-textual.out'))
         self.assertTrue(ok)
 
-    def testToFileBinary(self): # type: () -> None
+    def testToFileBinary(self):
         z = dns.zone.from_file(here('example'), 'example')
         try:
             f = open(here('example3-binary.out'), 'wb')
@@ -303,7 +303,7 @@ class ZoneTestCase(unittest.TestCase):
                 os.unlink(here('example3-binary.out'))
         self.assertTrue(ok)
 
-    def testToFileFilename(self): # type: () -> None
+    def testToFileFilename(self):
         z = dns.zone.from_file(here('example'), 'example')
         try:
             z.to_file(here('example3-filename.out'))
@@ -315,7 +315,7 @@ class ZoneTestCase(unittest.TestCase):
                 os.unlink(here('example3-filename.out'))
         self.assertTrue(ok)
 
-    def testToText(self): # type: () -> None
+    def testToText(self):
         z = dns.zone.from_file(here('example'), 'example')
         ok = False
         try:
@@ -331,7 +331,7 @@ class ZoneTestCase(unittest.TestCase):
                 os.unlink(here('example3.out'))
         self.assertTrue(ok)
 
-    def testFromText(self): # type: () -> None
+    def testFromText(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
         f = StringIO()
         names = list(z.nodes.keys())
@@ -341,7 +341,7 @@ class ZoneTestCase(unittest.TestCase):
             f.write('\n')
         self.assertEqual(f.getvalue(), example_text_output)
 
-    def testTorture1(self): # type: () -> None
+    def testTorture1(self):
         #
         # Read a zone containing all our supported RR types, and
         # for each RR in the zone, convert the rdata into wire format
@@ -362,151 +362,158 @@ class ZoneTestCase(unittest.TestCase):
                                               origin=o)
                     self.assertEqual(rd, rd2)
 
-    def testEqual(self): # type: () -> None
+    def testEqual(self):
         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): # type: () -> None
+    def testNotEqual1(self):
         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): # type: () -> None
+    def testNotEqual2(self):
         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): # type: () -> None
+    def testNotEqual3(self):
         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): # type: () -> None
+    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')
         self.assertEqual(rds, exrds)
 
-    def testFindRdataset2(self): # type: () -> None
-        def bad(): # type: () -> None
+    def testFindRdataset2(self):
+        def bad():
             z = dns.zone.from_text(example_text, 'example.', relativize=True)
             z.find_rdataset('@', 'loc')
         self.assertRaises(KeyError, bad)
 
-    def testFindRRset1(self): # type: () -> None
+    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')
         self.assertEqual(rrs, exrrs)
 
-    def testFindRRset2(self): # type: () -> None
-        def bad(): # type: () -> None
+    def testFindRRset2(self):
+        def bad():
             z = dns.zone.from_text(example_text, 'example.', relativize=True)
             z.find_rrset('@', 'loc')
         self.assertRaises(KeyError, bad)
 
-    def testGetRdataset1(self): # type: () -> None
+    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')
         self.assertEqual(rds, exrds)
 
-    def testGetRdataset2(self): # type: () -> None
+    def testGetRdataset2(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
         rds = z.get_rdataset('@', 'loc')
         self.assertTrue(rds is None)
 
-    def testGetRRset1(self): # type: () -> None
+    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')
         self.assertEqual(rrs, exrrs)
 
-    def testGetRRset2(self): # type: () -> None
+    def testGetRRset2(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
         rrs = z.get_rrset('@', 'loc')
         self.assertTrue(rrs is None)
 
-    def testReplaceRdataset1(self): # type: () -> 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')
         self.assertTrue(rds is rdataset)
 
-    def testReplaceRdataset2(self): # type: () -> None
+    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')
         self.assertTrue(rds is rdataset)
 
-    def testDeleteRdataset1(self): # type: () -> None
+    def testDeleteRdataset1(self):
         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): # type: () -> None
+    def testDeleteRdataset2(self):
         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): # type: () -> None
+    def testNodeFindRdataset1(self):
         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')
         self.assertEqual(rds, exrds)
 
-    def testNodeFindRdataset2(self): # type: () -> None
-        def bad(): # type: () -> None
+    def testNodeFindRdataset2(self):
+        def bad():
             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 testNodeGetRdataset1(self): # type: () -> None
+    def testNodeGetRdataset1(self):
         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')
         self.assertEqual(rds, exrds)
 
-    def testNodeGetRdataset2(self): # type: () -> None
+    def testNodeGetRdataset2(self):
         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): # type: () -> None
+    def testNodeDeleteRdataset1(self):
         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): # type: () -> None
+    def testNodeDeleteRdataset2(self):
         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 testIterateRdatasets(self): # type: () -> None
+    def testIterateNodes(self):
+        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')]
         ns.sort()
         self.assertEqual(ns, [dns.name.from_text('ns1', None),
                               dns.name.from_text('ns2', None)])
 
-    def testIterateAllRdatasets(self): # type: () -> None
+    def testIterateAllRdatasets(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
         ns = [n for n, r in z.iterate_rdatasets()]
         ns.sort()
@@ -516,7 +523,7 @@ class ZoneTestCase(unittest.TestCase):
                               dns.name.from_text('ns1', None),
                               dns.name.from_text('ns2', None)])
 
-    def testIterateRdatas(self): # type: () -> None
+    def testIterateRdatas(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
         l = list(z.iterate_rdatas('A'))
         l.sort()
@@ -530,7 +537,7 @@ class ZoneTestCase(unittest.TestCase):
                                     '10.0.0.2'))]
         self.assertEqual(l, exl)
 
-    def testIterateAllRdatas(self): # type: () -> None
+    def testIterateAllRdatas(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
         l = list(z.iterate_rdatas())
         l.sort(key=_rdata_sort)
@@ -572,17 +579,17 @@ class ZoneTestCase(unittest.TestCase):
         self.assertEqual(z.get('foo'), n)
         del z['foo']
         self.assertEqual(z.get('foo'), None)
-        def bad1():
+        with self.assertRaises(KeyError):
             z[123] = n
-        self.assertRaises(KeyError, bad1)
-        def bad2():
+        with self.assertRaises(KeyError):
             z['foo.'] = n
-        self.assertRaises(KeyError, bad2)
-        def bad3():
+        with self.assertRaises(KeyError):
             bn = z.find_node('bar')
-        self.assertRaises(KeyError, bad3)
         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')
 
     def testBadReplacement(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
@@ -591,7 +598,7 @@ class ZoneTestCase(unittest.TestCase):
             z.replace_rdataset('foo', rds)
         self.assertRaises(ValueError, bad)
 
-    def testTTLs(self): # type: () -> None
+    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))
@@ -603,7 +610,7 @@ class ZoneTestCase(unittest.TestCase):
         rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
         self.assertEqual(rds.ttl, 694861)
 
-    def testTTLFromSOA(self): # type: () -> None
+    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))
@@ -616,7 +623,7 @@ class ZoneTestCase(unittest.TestCase):
         rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
         self.assertEqual(rds.ttl, soa_rd.minimum)
 
-    def testTTLFromLast(self): # type: () -> None
+    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))
@@ -628,33 +635,33 @@ class ZoneTestCase(unittest.TestCase):
         rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
         self.assertEqual(rds.ttl, 694861)
 
-    def testNoTTL(self): # type: () -> None
-        def bad(): # type: () -> None
+    def testNoTTL(self):
+        def bad():
             dns.zone.from_text(no_ttl_text, 'example.', check_origin=False)
         self.assertRaises(dns.exception.SyntaxError, bad)
 
-    def testNoSOA(self): # type: () -> None
-        def bad(): # type: () -> None
+    def testNoSOA(self):
+        def bad():
             dns.zone.from_text(no_soa_text, 'example.', relativize=True)
         self.assertRaises(dns.zone.NoSOA, bad)
 
-    def testNoNS(self): # type: () -> None
-        def bad(): # type: () -> None
+    def testNoNS(self):
+        def bad():
             dns.zone.from_text(no_ns_text, 'example.', relativize=True)
         self.assertRaises(dns.zone.NoNS, bad)
 
-    def testInclude(self): # type: () -> None
+    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)
         self.assertEqual(z1, z2)
 
-    def testBadDirective(self): # type: () -> None
-        def bad(): # type: () -> None
+    def testBadDirective(self):
+        def bad():
             dns.zone.from_text(bad_directive_text, 'example.', relativize=True)
         self.assertRaises(dns.exception.SyntaxError, bad)
 
-    def testFirstRRStartsWithWhitespace(self): # type: () -> None
+    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)
@@ -662,21 +669,21 @@ class ZoneTestCase(unittest.TestCase):
         rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
         self.assertEqual(rds.ttl, 300)
 
-    def testZoneOrigin(self): # type: () -> None
+    def testZoneOrigin(self):
         z = dns.zone.Zone('example.')
         self.assertEqual(z.origin, dns.name.from_text('example.'))
-        def bad1(): # type: () -> None
+        def bad1():
             o = dns.name.from_text('example', None)
             dns.zone.Zone(o)
         self.assertRaises(ValueError, bad1)
-        def bad2(): # type: () -> None
+        def bad2():
             dns.zone.Zone(cast(str, 1.0))
         self.assertRaises(ValueError, bad2)
 
-    def testZoneOriginNone(self): # type: () -> None
+    def testZoneOriginNone(self):
         dns.zone.Zone(cast(str, None))
 
-    def testZoneFromXFR(self): # type: () -> None
+    def testZoneFromXFR(self):
         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)
@@ -771,5 +778,19 @@ class ZoneTestCase(unittest.TestCase):
         f.close()
         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')
+
+    def testUnsorted(self):
+        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)
+        self.assertEqual(z, z2)
+
 if __name__ == '__main__':
     unittest.main()