From: Brian Wellington Date: Wed, 18 Mar 2020 18:26:55 +0000 (-0700) Subject: Improve assertion checking. X-Git-Tag: v2.0.0rc1~327^2 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=e6798e58b4555740db4cfb43c8b9ce0d7d3416f1;p=thirdparty%2Fdnspython.git Improve assertion checking. This replaces lots of self.assertTrue() assertions with more specific assertions, such as replacing assertTrue(x == y) with assertEqual(x, y). --- diff --git a/tests/test_bugs.py b/tests/test_bugs.py index e7a3193a..c4b0e3cd 100644 --- a/tests/test_bugs.py +++ b/tests/test_bugs.py @@ -31,15 +31,15 @@ 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") - self.assertTrue(rdata.float_latitude == 30.5) - self.assertTrue(rdata.float_longitude == -100.5) + 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") - self.assertTrue(rdata1 == rdata2) + self.assertEqual(rdata1, rdata2) def test_TTL_bounds_check(self): def bad(): @@ -49,14 +49,14 @@ class BugsTestCase(unittest.TestCase): def test_empty_NSEC3_window(self): rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NSEC3, u"1 0 100 ABCD SCBCQHKU35969L2A68P3AD59LHF30715") - self.assertTrue(rdata.windows == []) + 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) - self.assertTrue(rdata == rdata2) + self.assertEqual(rdata, rdata2) def test_CAA_from_wire(self): rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CAA, @@ -68,19 +68,19 @@ class BugsTestCase(unittest.TestCase): wire += b"trailing garbage" rdata2 = dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.CAA, wire, 0, rdlen) - self.assertTrue(rdata == rdata2) + 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.assertTrue(text4 == '000101817f') + 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.assertTrue(text6 == '0002018f000000000000000000000000000010') + self.assertEqual(text6, '0002018f000000000000000000000000000010') def test_TXT_conversions(self): t1 = dns.rdtypes.ANY.TXT.TXT(dns.rdataclass.IN, dns.rdatatype.TXT, @@ -91,9 +91,9 @@ class BugsTestCase(unittest.TestCase): 'foo') t4 = dns.rdtypes.ANY.TXT.TXT(dns.rdataclass.IN, dns.rdatatype.TXT, ['foo']) - self.assertTrue(t1 == t2) - self.assertTrue(t1 == t2) - self.assertTrue(t1 == t4) + self.assertEqual(t1, t2) + self.assertEqual(t1, t2) + self.assertEqual(t1, t4) if __name__ == '__main__': unittest.main() diff --git a/tests/test_dnssec.py b/tests/test_dnssec.py index 2400014d..24ec2d26 100644 --- a/tests/test_dnssec.py +++ b/tests/test_dnssec.py @@ -298,15 +298,15 @@ class DNSSECMakeDSTestCase(unittest.TestCase): def testMakeExampleSHA1DS(self): # type: () -> None ds = dns.dnssec.make_ds(abs_example, example_sep_key, 'SHA1') - self.assertTrue(ds == example_ds_sha1) + self.assertEqual(ds, example_ds_sha1) def testMakeExampleSHA256DS(self): # type: () -> None ds = dns.dnssec.make_ds(abs_example, example_sep_key, 'SHA256') - self.assertTrue(ds == example_ds_sha256) + self.assertEqual(ds, example_ds_sha256) def testMakeSHA256DS(self): # type: () -> None ds = dns.dnssec.make_ds(abs_dnspython_org, sep_key, 'SHA256') - self.assertTrue(ds == good_ds) + self.assertEqual(ds, good_ds) if __name__ == '__main__': diff --git a/tests/test_flags.py b/tests/test_flags.py index 20c200d1..f3e7f845 100644 --- a/tests/test_flags.py +++ b/tests/test_flags.py @@ -24,24 +24,24 @@ import dns.opcode class FlagsTestCase(unittest.TestCase): def test_rcode1(self): - self.assertTrue(dns.rcode.from_text('FORMERR') == dns.rcode.FORMERR) + self.assertEqual(dns.rcode.from_text('FORMERR'), dns.rcode.FORMERR) def test_rcode2(self): - self.assertTrue(dns.rcode.to_text(dns.rcode.FORMERR) == "FORMERR") + self.assertEqual(dns.rcode.to_text(dns.rcode.FORMERR), "FORMERR") def test_rcode3(self): - self.assertTrue(dns.rcode.to_flags(dns.rcode.FORMERR) == (1, 0)) + self.assertEqual(dns.rcode.to_flags(dns.rcode.FORMERR), (1, 0)) def test_rcode4(self): - self.assertTrue(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.assertTrue(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.assertTrue(dns.rcode.from_flags(5, 0) == dns.rcode.REFUSED) + self.assertEqual(dns.rcode.from_flags(5, 0), dns.rcode.REFUSED) def test_rcode8(self): def bad(): @@ -49,12 +49,12 @@ class FlagsTestCase(unittest.TestCase): self.assertRaises(ValueError, bad) def test_flags1(self): - self.assertTrue(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 - self.assertTrue(dns.flags.to_text(flags) == "QR AA RD RA") + self.assertEqual(dns.flags.to_text(flags), "QR AA RD RA") if __name__ == '__main__': diff --git a/tests/test_generate.py b/tests/test_generate.py index bcd116b9..87ef664d 100644 --- a/tests/test_generate.py +++ b/tests/test_generate.py @@ -200,7 +200,7 @@ class GenerateTestCase(unittest.TestCase): '10.0.0.5'))] exl.sort(key=_rdata_sort) - self.assertTrue(l == exl) + self.assertEqual(l, exl) def testIterateAllRdatas3(self): # type: () -> None z = dns.zone.from_text(example_text3, 'example.', relativize=True) @@ -240,7 +240,7 @@ class GenerateTestCase(unittest.TestCase): dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, '10.0.0.8'))] exl.sort(key=_rdata_sort) - self.assertTrue(l == exl) + self.assertEqual(l, exl) def testGenerate1(self): # type: () -> None z = dns.zone.from_text(example_text4, 'example.', relativize=True) l = list(z.iterate_rdatas()) @@ -328,7 +328,7 @@ class GenerateTestCase(unittest.TestCase): dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME, 'SERVER.FOOBAR.'))] exl.sort(key=_rdata_sort) - self.assertTrue(l == exl) + self.assertEqual(l, exl) def testGenerate3(self): # type: () -> None z = dns.zone.from_text(example_text6, 'example.', relativize=True) @@ -371,7 +371,7 @@ class GenerateTestCase(unittest.TestCase): dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME, 'SERVER.FOOBAR.'))] exl.sort(key=_rdata_sort) - self.assertTrue(l == exl) + self.assertEqual(l, exl) def testGenerate4(self): # type: () -> None z = dns.zone.from_text(example_text7, 'example.', relativize=True) @@ -414,7 +414,7 @@ class GenerateTestCase(unittest.TestCase): dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, '10.10.16.0'))] exl.sort(key=_rdata_sort) - self.assertTrue(l == exl) + self.assertEqual(l, exl) def testGenerate6(self): # type: () -> None z = dns.zone.from_text(example_text9, 'example.', relativize=True) @@ -464,7 +464,7 @@ class GenerateTestCase(unittest.TestCase): dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, '10.10.16.0'))] exl.sort(key=_rdata_sort) - self.assertTrue(l == exl) + self.assertEqual(l, exl) def testGenerate7(self): # type: () -> None z = dns.zone.from_text(example_text10, 'example.', relativize=True) @@ -504,7 +504,7 @@ class GenerateTestCase(unittest.TestCase): 'zlb2.oob'))] exl.sort(key=_rdata_sort) - self.assertTrue(l == exl) + self.assertEqual(l, exl) def testGenerate8(self): # type: () -> None z = dns.zone.from_text(example_text11, 'example.', relativize=True) @@ -545,7 +545,7 @@ class GenerateTestCase(unittest.TestCase): '10.0.0.2'))] exl.sort(key=_rdata_sort) - self.assertTrue(l == exl) + self.assertEqual(l, exl) if __name__ == '__main__': diff --git a/tests/test_message.py b/tests/test_message.py index 34512f00..b7995862 100644 --- a/tests/test_message.py +++ b/tests/test_message.py @@ -96,28 +96,28 @@ class MessageTestCase(unittest.TestCase): def test_comparison_eq1(self): q1 = dns.message.from_text(query_text) q2 = dns.message.from_text(query_text) - self.assertTrue(q1 == q2) + self.assertEqual(q1, q2) def test_comparison_ne1(self): q1 = dns.message.from_text(query_text) q2 = dns.message.from_text(query_text) q2.id = 10 - self.assertTrue(q1 != q2) + self.assertNotEqual(q1, q2) def test_comparison_ne2(self): q1 = dns.message.from_text(query_text) q2 = dns.message.from_text(query_text) q2.question = [] - self.assertTrue(q1 != q2) + self.assertNotEqual(q1, q2) def test_comparison_ne3(self): q1 = dns.message.from_text(query_text) - self.assertTrue(q1 != 1) + self.assertNotEqual(q1, 1) def test_EDNS_to_wire1(self): q = dns.message.from_text(query_text) w = q.to_wire() - self.assertTrue(w == goodwire) + self.assertEqual(w, goodwire) def test_EDNS_from_wire1(self): m = dns.message.from_wire(goodwire) @@ -126,11 +126,11 @@ class MessageTestCase(unittest.TestCase): def test_EDNS_to_wire2(self): q = dns.message.from_text(query_text_2) w = q.to_wire() - self.assertTrue(w == goodwire3) + self.assertEqual(w, goodwire3) def test_EDNS_from_wire2(self): m = dns.message.from_wire(goodwire3) - self.assertTrue(str(m) == query_text_2) + self.assertEqual(str(m), query_text_2) def test_TooBig(self): def bad(): @@ -147,7 +147,7 @@ class MessageTestCase(unittest.TestCase): def test_answer1(self): a = dns.message.from_text(answer_text) wire = a.to_wire(want_shuffle=False) - self.assertTrue(wire == goodwire2) + self.assertEqual(wire, goodwire2) def test_TrailingJunk(self): def bad(): @@ -171,34 +171,34 @@ class MessageTestCase(unittest.TestCase): def test_ExtendedRcodeSetting(self): m = dns.message.make_query('foo', 'A') m.set_rcode(4095) - self.assertTrue(m.rcode() == 4095) + self.assertEqual(m.rcode(), 4095) m.set_rcode(2) - self.assertTrue(m.rcode() == 2) + self.assertEqual(m.rcode(), 2) def test_EDNSVersionCoherence(self): m = dns.message.make_query('foo', 'A') m.use_edns(1) - self.assertTrue((m.ednsflags >> 16) & 0xFF == 1) + self.assertEqual((m.ednsflags >> 16) & 0xFF, 1) def test_SettingNoEDNSOptionsImpliesNoEDNS(self): m = dns.message.make_query('foo', 'A') - self.assertTrue(m.edns == -1) + self.assertEqual(m.edns, -1) def test_SettingEDNSFlagsImpliesEDNS(self): m = dns.message.make_query('foo', 'A', ednsflags=dns.flags.DO) - self.assertTrue(m.edns == 0) + self.assertEqual(m.edns, 0) def test_SettingEDNSPayloadImpliesEDNS(self): m = dns.message.make_query('foo', 'A', payload=4096) - self.assertTrue(m.edns == 0) + self.assertEqual(m.edns, 0) def test_SettingEDNSRequestPayloadImpliesEDNS(self): m = dns.message.make_query('foo', 'A', request_payload=4096) - self.assertTrue(m.edns == 0) + self.assertEqual(m.edns, 0) def test_SettingOptionsImpliesEDNS(self): m = dns.message.make_query('foo', 'A', options=[]) - self.assertTrue(m.edns == 0) + self.assertEqual(m.edns, 0) def test_FindRRset(self): a = dns.message.from_text(answer_text) @@ -206,7 +206,7 @@ class MessageTestCase(unittest.TestCase): 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) - self.assertTrue(rrs1 == rrs2) + self.assertEqual(rrs1, rrs2) def test_CleanTruncated(self): def bad(): diff --git a/tests/test_name.py b/tests/test_name.py index bbe8d1d6..0f08e870 100644 --- a/tests/test_name.py +++ b/tests/test_name.py @@ -48,11 +48,11 @@ class NameTestCase(unittest.TestCase): def testFromTextRel4(self): n = dns.name.from_text('@', origin=None) - self.assertTrue(n == dns.name.empty) + self.assertEqual(n, dns.name.empty) def testFromTextRel5(self): n = dns.name.from_text('@', origin=self.origin) - self.assertTrue(n == self.origin) + self.assertEqual(n, self.origin) def testFromTextAbs1(self): n = dns.name.from_text('foo.bar.') @@ -112,14 +112,14 @@ class NameTestCase(unittest.TestCase): self.assertTrue(dns.name.root.is_absolute()) def testAbs2(self): - self.assertTrue(not dns.name.empty.is_absolute()) + self.assertFalse(dns.name.empty.is_absolute()) def testAbs3(self): self.assertTrue(self.origin.is_absolute()) def testAbs4(self): n = dns.name.from_text('foo', origin=None) - self.assertTrue(not n.is_absolute()) + self.assertFalse(n.is_absolute()) def testWild1(self): n = dns.name.from_text('*.foo', origin=None) @@ -127,17 +127,17 @@ class NameTestCase(unittest.TestCase): def testWild2(self): n = dns.name.from_text('*a.foo', origin=None) - self.assertTrue(not n.is_wild()) + self.assertFalse(n.is_wild()) def testWild3(self): n = dns.name.from_text('a.*.foo', origin=None) - self.assertTrue(not n.is_wild()) + self.assertFalse(n.is_wild()) def testWild4(self): - self.assertTrue(not dns.name.root.is_wild()) + self.assertFalse(dns.name.root.is_wild()) def testWild5(self): - self.assertTrue(not dns.name.empty.is_wild()) + self.assertFalse(dns.name.empty.is_wild()) def testHash1(self): n1 = dns.name.from_text('fOo.COM') @@ -147,27 +147,27 @@ class NameTestCase(unittest.TestCase): def testCompare1(self): n1 = dns.name.from_text('a') n2 = dns.name.from_text('b') - self.assertTrue(n1 < n2) - self.assertTrue(n2 > n1) + self.assertLess(n1, n2) + self.assertGreater(n2, n1) def testCompare2(self): n1 = dns.name.from_text('') n2 = dns.name.from_text('b') - self.assertTrue(n1 < n2) - self.assertTrue(n2 > n1) + self.assertLess(n1, n2) + self.assertGreater(n2, n1) def testCompare3(self): - self.assertTrue(dns.name.empty < dns.name.root) - self.assertTrue(dns.name.root > dns.name.empty) + self.assertLess(dns.name.empty, dns.name.root) + self.assertGreater(dns.name.root, dns.name.empty) def testCompare4(self): - self.assertTrue(dns.name.root != 1) + self.assertNotEqual(dns.name.root, 1) def testSubdomain1(self): - self.assertTrue(not dns.name.empty.is_subdomain(dns.name.root)) + self.assertFalse(dns.name.empty.is_subdomain(dns.name.root)) def testSubdomain2(self): - self.assertTrue(not dns.name.root.is_subdomain(dns.name.empty)) + self.assertFalse(dns.name.root.is_subdomain(dns.name.empty)) def testSubdomain3(self): n = dns.name.from_text('foo', origin=self.origin) @@ -182,10 +182,10 @@ class NameTestCase(unittest.TestCase): self.assertTrue(n.is_subdomain(n)) def testSuperdomain1(self): - self.assertTrue(not dns.name.empty.is_superdomain(dns.name.root)) + self.assertFalse(dns.name.empty.is_superdomain(dns.name.root)) def testSuperdomain2(self): - self.assertTrue(not dns.name.root.is_superdomain(dns.name.empty)) + self.assertFalse(dns.name.root.is_superdomain(dns.name.empty)) def testSuperdomain3(self): n = dns.name.from_text('foo', origin=self.origin) @@ -324,35 +324,35 @@ class NameTestCase(unittest.TestCase): n2 = dns.name.Name(['c', 'd']) e = dns.name.Name(['a', 'b', 'c', 'd']) r = n1 + n2 - self.assertTrue(r == e) + self.assertEqual(r, e) def testConcat2(self): n1 = dns.name.Name(['a', 'b']) n2 = dns.name.Name([]) e = dns.name.Name(['a', 'b']) r = n1 + n2 - self.assertTrue(r == e) + self.assertEqual(r, e) def testConcat3(self): n1 = dns.name.Name([]) n2 = dns.name.Name(['a', 'b']) e = dns.name.Name(['a', 'b']) r = n1 + n2 - self.assertTrue(r == e) + self.assertEqual(r, e) def testConcat4(self): n1 = dns.name.Name(['a', 'b', '']) n2 = dns.name.Name([]) e = dns.name.Name(['a', 'b', '']) r = n1 + n2 - self.assertTrue(r == e) + 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', '']) r = n1 + n2 - self.assertTrue(r == e) + self.assertEqual(r, e) def testConcat6(self): def bad(): @@ -377,7 +377,7 @@ class NameTestCase(unittest.TestCase): n2 = dns.name.from_text('foo.BAR.') d1 = n1.to_digestable() d2 = n2.to_digestable() - self.assertTrue(d1 == d2) + self.assertEqual(d1, d2) def testDigestable3(self): d = dns.name.root.to_digestable() @@ -455,28 +455,32 @@ class NameTestCase(unittest.TestCase): (prefix, suffix) = n.split(2) ep = dns.name.from_text('foo', None) es = dns.name.from_text('bar.', None) - self.assertTrue(prefix == ep and suffix == es) + self.assertEqual(prefix, ep) + self.assertEqual(suffix, es) def testSplit2(self): 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) - self.assertTrue(prefix == ep and suffix == es) + self.assertEqual(prefix, ep) + self.assertEqual(suffix, es) def testSplit3(self): 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) - self.assertTrue(prefix == ep and suffix == es) + self.assertEqual(prefix, ep) + self.assertEqual(suffix, es) def testSplit4(self): 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) - self.assertTrue(prefix == ep and suffix == es) + self.assertEqual(prefix, ep) + self.assertEqual(suffix, es) def testBadSplit1(self): def bad(): @@ -494,85 +498,85 @@ class NameTestCase(unittest.TestCase): 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.assertTrue(n.relativize(o) == e) + self.assertEqual(n.relativize(o), e) def testRelativize2(self): n = dns.name.from_text('a.foo.bar.', None) o = n e = dns.name.empty - self.assertTrue(n.relativize(o) == e) + 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) e = n - self.assertTrue(n.relativize(o) == e) + self.assertEqual(n.relativize(o), e) def testRelativize4(self): n = dns.name.from_text('a.foo', None) o = dns.name.root e = n - self.assertTrue(n.relativize(o) == e) + 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) - self.assertTrue(n.derelativize(o) == e) + self.assertEqual(n.derelativize(o), e) def testDerelativize2(self): n = dns.name.empty o = dns.name.from_text('a.foo.bar.', None) e = o - self.assertTrue(n.derelativize(o) == e) + 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) e = n - self.assertTrue(n.derelativize(o) == e) + 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) - self.assertTrue(n.choose_relativity(o, True) == e) + 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) e = n - self.assertTrue(n.choose_relativity(o, False) == e) + 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) - self.assertTrue(n.choose_relativity(o, False) == e) + self.assertEqual(n.choose_relativity(o, False), e) def testChooseRelativity4(self): n = dns.name.from_text('a.foo', None) o = None e = n - self.assertTrue(n.choose_relativity(o, True) == e) + self.assertEqual(n.choose_relativity(o, True), e) def testChooseRelativity5(self): n = dns.name.from_text('a.foo', None) o = None e = n - self.assertTrue(n.choose_relativity(o, False) == e) + self.assertEqual(n.choose_relativity(o, False), e) def testChooseRelativity6(self): n = dns.name.from_text('a.foo.', None) o = None e = n - self.assertTrue(n.choose_relativity(o, True) == e) + self.assertEqual(n.choose_relativity(o, True), e) def testChooseRelativity7(self): n = dns.name.from_text('a.foo.', None) o = None e = n - self.assertTrue(n.choose_relativity(o, False) == e) + self.assertEqual(n.choose_relativity(o, False), e) def testFromWire1(self): w = b'\x03foo\x00\xc0\x00' @@ -582,8 +586,10 @@ class NameTestCase(unittest.TestCase): en2 = en1 ecused1 = 5 ecused2 = 2 - self.assertTrue(n1 == en1 and cused1 == ecused1 and \ - n2 == en2 and cused2 == ecused2) + self.assertEqual(n1, en1) + self.assertEqual(cused1, ecused1) + self.assertEqual(n2, en2) + self.assertEqual(cused2, ecused2) def testFromWire2(self): w = b'\x03foo\x00\x01a\xc0\x00\x01b\xc0\x05' @@ -599,9 +605,12 @@ class NameTestCase(unittest.TestCase): ecused1 = 5 ecused2 = 4 ecused3 = 4 - self.assertTrue(n1 == en1 and cused1 == ecused1 and \ - n2 == en2 and cused2 == ecused2 and \ - n3 == en3 and cused3 == ecused3) + self.assertEqual(n1, en1) + self.assertEqual(cused1, ecused1) + self.assertEqual(n2, en2) + self.assertEqual(cused2, ecused2) + self.assertEqual(n3, en3) + self.assertEqual(cused3, ecused3) def testBadFromWire1(self): def bad(): @@ -629,13 +638,13 @@ class NameTestCase(unittest.TestCase): def testParent1(self): n = dns.name.from_text('foo.bar.') - self.assertTrue(n.parent() == dns.name.from_text('bar.')) - self.assertTrue(n.parent().parent() == dns.name.root) + 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.assertTrue(n.parent() == dns.name.from_text('bar', None)) - self.assertTrue(n.parent().parent() == dns.name.empty) + self.assertEqual(n.parent(), dns.name.from_text('bar', None)) + self.assertEqual(n.parent().parent(), dns.name.empty) def testParent3(self): def bad(): @@ -783,7 +792,7 @@ class NameTestCase(unittest.TestCase): 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') - self.assertTrue(e == n) + self.assertEqual(e, n) def testBadReverseIPv4(self): def bad(): @@ -811,7 +820,7 @@ class NameTestCase(unittest.TestCase): 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.assertTrue(n == e) + 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.') diff --git a/tests/test_namedict.py b/tests/test_namedict.py index 97a5252a..d1beba6c 100644 --- a/tests/test_namedict.py +++ b/tests/test_namedict.py @@ -35,23 +35,23 @@ class NameTestCase(unittest.TestCase): self.rndict[n2] = 2 def testDepth(self): - self.assertTrue(self.ndict.max_depth == 3) + self.assertEqual(self.ndict.max_depth, 3) def testLookup1(self): k = dns.name.from_text('foo.bar.') - self.assertTrue(self.ndict[k] == 1) + self.assertEqual(self.ndict[k], 1) def testLookup2(self): k = dns.name.from_text('foo.bar.') - self.assertTrue(self.ndict.get_deepest_match(k)[1] == 1) + self.assertEqual(self.ndict.get_deepest_match(k)[1], 1) def testLookup3(self): k = dns.name.from_text('a.b.c.foo.bar.') - self.assertTrue(self.ndict.get_deepest_match(k)[1] == 1) + self.assertEqual(self.ndict.get_deepest_match(k)[1], 1) def testLookup4(self): k = dns.name.from_text('a.b.c.bar.') - self.assertTrue(self.ndict.get_deepest_match(k)[1] == 2) + self.assertEqual(self.ndict.get_deepest_match(k)[1], 2) def testLookup5(self): def bad(): @@ -68,7 +68,7 @@ class NameTestCase(unittest.TestCase): self.ndict[dns.name.empty] = 100 n = dns.name.from_text('a.b.c.') v = self.ndict.get_deepest_match(n)[1] - self.assertTrue(v == 100) + self.assertEqual(v, 100) def testLookup8(self): def bad(): @@ -76,29 +76,29 @@ class NameTestCase(unittest.TestCase): self.assertRaises(ValueError, bad) def testRelDepth(self): - self.assertTrue(self.rndict.max_depth == 2) + self.assertEqual(self.rndict.max_depth, 2) def testRelLookup1(self): k = dns.name.from_text('foo.bar', None) - self.assertTrue(self.rndict[k] == 1) + self.assertEqual(self.rndict[k] ,1) def testRelLookup2(self): k = dns.name.from_text('foo.bar', None) - self.assertTrue(self.rndict.get_deepest_match(k)[1] == 1) + self.assertEqual(self.rndict.get_deepest_match(k)[1], 1) def testRelLookup3(self): k = dns.name.from_text('a.b.c.foo.bar', None) - self.assertTrue(self.rndict.get_deepest_match(k)[1] == 1) + self.assertEqual(self.rndict.get_deepest_match(k)[1], 1) def testRelLookup4(self): k = dns.name.from_text('a.b.c.bar', None) - self.assertTrue(self.rndict.get_deepest_match(k)[1] == 2) + 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) v = self.rndict.get_deepest_match(n)[1] - self.assertTrue(v == 100) + self.assertEqual(v, 100) if __name__ == '__main__': unittest.main() diff --git a/tests/test_ntoaaton.py b/tests/test_ntoaaton.py index 36d85f6b..1b2c476b 100644 --- a/tests/test_ntoaaton.py +++ b/tests/test_ntoaaton.py @@ -39,19 +39,19 @@ class NtoAAtoNTestCase(unittest.TestCase): def test_aton1(self): a = aton6('::') - self.assertTrue(a == b'\x00' * 16) + self.assertEqual(a, b'\x00' * 16) def test_aton2(self): a = aton6('::1') - self.assertTrue(a == b'\x00' * 15 + b'\x01') + self.assertEqual(a, b'\x00' * 15 + b'\x01') def test_aton3(self): a = aton6('::10.0.0.1') - self.assertTrue(a == b'\x00' * 12 + b'\x0a\x00\x00\x01') + self.assertEqual(a, b'\x00' * 12 + b'\x0a\x00\x00\x01') def test_aton4(self): a = aton6('abcd::dcba') - self.assertTrue(a == b'\xab\xcd' + b'\x00' * 12 + b'\xdc\xba') + 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') diff --git a/tests/test_rdata.py b/tests/test_rdata.py index 43e1a673..9ea3ca7c 100644 --- a/tests/test_rdata.py +++ b/tests/test_rdata.py @@ -27,19 +27,19 @@ class RdataTestCase(unittest.TestCase): def test_str(self): rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "1.2.3.4") - self.assertTrue(rdata.address == "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") - self.assertTrue(rdata.address == "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.assertTrue(rdata.strings == [b'hello', b'world']) - self.assertTrue(dns.rdatatype.to_text(TTXT) == 'TTXT') - self.assertTrue(dns.rdatatype.from_text('TTXT') == TTXT) + 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(): diff --git a/tests/test_rdtypeandclass.py b/tests/test_rdtypeandclass.py index fd696d20..e7b6da26 100644 --- a/tests/test_rdtypeandclass.py +++ b/tests/test_rdtypeandclass.py @@ -28,18 +28,17 @@ class RdTypeAndClassTestCase(unittest.TestCase): self.assertTrue(dns.rdataclass.is_metaclass(dns.rdataclass.ANY)) def test_class_meta2(self): - self.assertTrue(not dns.rdataclass.is_metaclass(dns.rdataclass.IN)) + self.assertFalse(dns.rdataclass.is_metaclass(dns.rdataclass.IN)) def test_class_bytext1(self): - self.assertTrue(dns.rdataclass.from_text('IN') == dns.rdataclass.IN) + self.assertEqual(dns.rdataclass.from_text('IN'), dns.rdataclass.IN) def test_class_bytext2(self): - self.assertTrue(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.assertTrue(dns.rdataclass.from_text('CLASS0') == 0) - self.assertTrue(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(): @@ -52,10 +51,10 @@ class RdTypeAndClassTestCase(unittest.TestCase): self.assertRaises(dns.rdataclass.UnknownRdataclass, bad) def test_class_totext1(self): - self.assertTrue(dns.rdataclass.to_text(dns.rdataclass.IN) == 'IN') + self.assertEqual(dns.rdataclass.to_text(dns.rdataclass.IN), 'IN') def test_class_totext2(self): - self.assertTrue(dns.rdataclass.to_text(999) == 'CLASS999') + self.assertEqual(dns.rdataclass.to_text(999), 'CLASS999') def test_class_totext_bounds1(self): def bad(): @@ -76,24 +75,23 @@ class RdTypeAndClassTestCase(unittest.TestCase): self.assertTrue(dns.rdatatype.is_metatype(dns.rdatatype.OPT)) def test_type_meta3(self): - self.assertTrue(not dns.rdatatype.is_metatype(dns.rdatatype.A)) + self.assertFalse(dns.rdatatype.is_metatype(dns.rdatatype.A)) def test_type_singleton1(self): self.assertTrue(dns.rdatatype.is_singleton(dns.rdatatype.SOA)) def test_type_singleton2(self): - self.assertTrue(not dns.rdatatype.is_singleton(dns.rdatatype.A)) + self.assertFalse(dns.rdatatype.is_singleton(dns.rdatatype.A)) def test_type_bytext1(self): - self.assertTrue(dns.rdatatype.from_text('A') == dns.rdatatype.A) + self.assertEqual(dns.rdatatype.from_text('A'), dns.rdatatype.A) def test_type_bytext2(self): - self.assertTrue(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.assertTrue(dns.rdatatype.from_text('TYPE0') == 0) - self.assertTrue(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(): @@ -106,10 +104,10 @@ class RdTypeAndClassTestCase(unittest.TestCase): self.assertRaises(dns.rdatatype.UnknownRdatatype, bad) def test_type_totext1(self): - self.assertTrue(dns.rdatatype.to_text(dns.rdatatype.A) == 'A') + self.assertEqual(dns.rdatatype.to_text(dns.rdatatype.A), 'A') def test_type_totext2(self): - self.assertTrue(dns.rdatatype.to_text(999) == 'TYPE999') + self.assertEqual(dns.rdatatype.to_text(999), 'TYPE999') def test_type_totext_bounds1(self): def bad(): @@ -122,7 +120,7 @@ class RdTypeAndClassTestCase(unittest.TestCase): self.assertRaises(ValueError, bad) def test_type0_totext(self): - self.assertTrue(dns.rdatatype.to_text(0) == 'TYPE0') + self.assertEqual(dns.rdatatype.to_text(0), 'TYPE0') if __name__ == '__main__': unittest.main() diff --git a/tests/test_rdtypeanydnskey.py b/tests/test_rdtypeanydnskey.py index 967facc5..d354aa50 100644 --- a/tests/test_rdtypeanydnskey.py +++ b/tests/test_rdtypeanydnskey.py @@ -28,28 +28,28 @@ class RdtypeAnyDnskeyTestCase(unittest.TestCase): good_s = set() #type: Set[str] good_f = 0 from_flags = dns.rdtypes.ANY.DNSKEY.flags_to_text_set(good_f) - self.assertTrue(from_flags == good_s, - '"{}" != "{}"'.format(from_flags, good_s)) + self.assertEqual(from_flags, good_s, + '"{}" != "{}"'.format(from_flags, good_s)) from_set = dns.rdtypes.ANY.DNSKEY.flags_from_text_set(good_s) - self.assertTrue(from_set == good_f, - '"0x{:x}" != "0x{:x}"'.format(from_set, good_f)) + self.assertEqual(from_set, good_f, + '"0x{:x}" != "0x{:x}"'.format(from_set, good_f)) def testFlagsAll(self): # type: () -> None '''Test that all defined flags are recognized.''' good_s = {'SEP', 'REVOKE', 'ZONE'} good_f = 0x181 from_flags = dns.rdtypes.ANY.DNSKEY.flags_to_text_set(good_f) - self.assertTrue(from_flags == good_s, - '"{}" != "{}"'.format(from_flags, good_s)) + self.assertEqual(from_flags, good_s, + '"{}" != "{}"'.format(from_flags, good_s)) from_text = dns.rdtypes.ANY.DNSKEY.flags_from_text_set(good_s) - self.assertTrue(from_text == good_f, - '"0x{:x}" != "0x{:x}"'.format(from_text, good_f)) + self.assertEqual(from_text, good_f, + '"0x{:x}" != "0x{:x}"'.format(from_text, good_f)) def testFlagsUnknownToText(self): # type: () -> None '''Test that undefined flags are returned in hexadecimal notation.''' unk_s = {'0x8000'} flags_s = dns.rdtypes.ANY.DNSKEY.flags_to_text_set(0x8000) - self.assertTrue(flags_s == unk_s, '"{}" != "{}"'.format(flags_s, unk_s)) + self.assertEqual(flags_s, unk_s, '"{}" != "{}"'.format(flags_s, unk_s)) def testFlagsUnknownToFlags(self): # type: () -> None '''Test that conversion from undefined mnemonic raises error.''' @@ -62,7 +62,7 @@ class RdtypeAnyDnskeyTestCase(unittest.TestCase): rr = dns.rrset.from_text('foo', 300, 'IN', 'DNSKEY', '257 3 8 KEY=')[0] rr_s = {'ZONE', 'SEP'} flags_s = rr.flags_to_text_set() - self.assertTrue(flags_s == rr_s, '"{}" != "{}"'.format(flags_s, rr_s)) + self.assertEqual(flags_s, rr_s, '"{}" != "{}"'.format(flags_s, rr_s)) if __name__ == '__main__': diff --git a/tests/test_rdtypeanyloc.py b/tests/test_rdtypeanyloc.py index 0509b8c8..23a1f68c 100644 --- a/tests/test_rdtypeanyloc.py +++ b/tests/test_rdtypeanyloc.py @@ -28,7 +28,7 @@ class RdtypeAnyLocTestCase(unittest.TestCase): 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.assertTrue(r1 == r2, '"{}" != "{}"'.format(r1, r2)) + self.assertEqual(r1, r2, '"{}" != "{}"'.format(r1, r2)) def testEqual2(self): '''Test default values for size, horizontal and vertical precision.''' @@ -39,7 +39,7 @@ class RdtypeAnyLocTestCase(unittest.TestCase): (16, 36, 29, 600, 1), 22764.0, # centimeters 100.0, 1000000.00, 1000.0) # centimeters - self.assertTrue(r1 == r2, '"{}" != "{}"'.format(r1, r2)) + self.assertEqual(r1, r2, '"{}" != "{}"'.format(r1, r2)) def testEqual3(self): '''Test size, horizontal and vertical precision parsers: 100 cm == 1 m. @@ -51,7 +51,7 @@ class RdtypeAnyLocTestCase(unittest.TestCase): 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.assertTrue(r1 == r2, '"{}" != "{}"'.format(r1, r2)) + self.assertEqual(r1, r2, '"{}" != "{}"'.format(r1, r2)) def testEqual4(self): '''Test size, horizontal and vertical precision parsers without unit. @@ -64,7 +64,7 @@ class RdtypeAnyLocTestCase(unittest.TestCase): 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.assertTrue(r1 == r2, '"{}" != "{}"'.format(r1, r2)) + self.assertEqual(r1, r2, '"{}" != "{}"'.format(r1, r2)) if __name__ == '__main__': unittest.main() diff --git a/tests/test_resolver.py b/tests/test_resolver.py index 993a5820..3d447803 100644 --- a/tests/test_resolver.py +++ b/tests/test_resolver.py @@ -107,8 +107,8 @@ class BaseResolverTests(unittest.TestCase): def testRead(self): f = StringIO(resolv_conf) r = dns.resolver.Resolver(f) - self.assertTrue(r.nameservers == ['10.0.0.1', '10.0.0.2'] and - 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 testCacheExpiration(self): message = dns.message.from_text(message_text) @@ -157,21 +157,21 @@ class BaseResolverTests(unittest.TestCase): name = dns.name.from_text('www.dnspython.org.') ezname = dns.name.from_text('dnspython.org.') zname = dns.resolver.zone_for_name(name) - self.assertTrue(zname == ezname) + self.assertEqual(zname, ezname) @unittest.skipIf(not _network_available, "Internet not reachable") def testZoneForName2(self): name = dns.name.from_text('a.b.www.dnspython.org.') ezname = dns.name.from_text('dnspython.org.') zname = dns.resolver.zone_for_name(name) - self.assertTrue(zname == ezname) + self.assertEqual(zname, ezname) @unittest.skipIf(not _network_available, "Internet not reachable") def testZoneForName3(self): name = dns.name.from_text('dnspython.org.') ezname = dns.name.from_text('dnspython.org.') zname = dns.resolver.zone_for_name(name) - self.assertTrue(zname == ezname) + self.assertEqual(zname, ezname) def testZoneForName4(self): def bad(): @@ -282,27 +282,27 @@ class NXDOMAINExceptionTestCase(unittest.TestCase): try: raise dns.resolver.NXDOMAIN except dns.exception.DNSException as e: - self.assertTrue((e.args == (e.__doc__,))) + self.assertEqual(e.args, (e.__doc__,)) self.assertTrue(('kwargs' in dir(e))) - self.assertTrue((str(e) == e.__doc__), str(e)) + self.assertEqual(str(e), e.__doc__, str(e)) 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.assertTrue((e.args == ("errmsg",))) + self.assertEqual(e.args, ("errmsg",)) self.assertTrue(('kwargs' in dir(e))) - self.assertTrue((str(e) == "errmsg"), str(e)) + self.assertEqual(str(e), "errmsg", str(e)) 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.assertTrue((e.args == ("errmsg", -1))) + self.assertEqual(e.args, ("errmsg", -1)) self.assertTrue(('kwargs' in dir(e))) - self.assertTrue((str(e) == "('errmsg', -1)"), str(e)) + self.assertEqual(str(e), "('errmsg', -1)", str(e)) self.assertTrue(('qnames' not in e.kwargs)) self.assertTrue(('responses' not in e.kwargs)) @@ -325,13 +325,13 @@ class NXDOMAINExceptionTestCase(unittest.TestCase): raise dns.resolver.NXDOMAIN(qnames=[n1]) except dns.exception.DNSException as e: MSG = "The DNS query name does not exist: a.b." - self.assertTrue((e.args == (MSG,)), repr(e.args)) + self.assertEqual(e.args, (MSG,), repr(e.args)) self.assertTrue(('kwargs' in dir(e))) - self.assertTrue((str(e) == MSG), str(e)) + self.assertEqual(str(e), MSG, str(e)) self.assertTrue(('qnames' in e.kwargs)) - self.assertTrue((e.kwargs['qnames'] == [n1])) + self.assertEqual(e.kwargs['qnames'], [n1]) self.assertTrue(('responses' in e.kwargs)) - self.assertTrue((e.kwargs['responses'] == {})) + self.assertEqual(e.kwargs['responses'], {}) try: raise dns.resolver.NXDOMAIN(qnames=[n2, n1]) @@ -339,13 +339,13 @@ class NXDOMAINExceptionTestCase(unittest.TestCase): e0 = dns.resolver.NXDOMAIN("errmsg") e = e0 + e MSG = "None of DNS query names exist: a.b.s., a.b." - self.assertTrue((e.args == (MSG,)), repr(e.args)) + self.assertEqual(e.args, (MSG,), repr(e.args)) self.assertTrue(('kwargs' in dir(e))) - self.assertTrue((str(e) == MSG), str(e)) + self.assertEqual(str(e), MSG, str(e)) self.assertTrue(('qnames' in e.kwargs)) - self.assertTrue((e.kwargs['qnames'] == [n2, n1])) + self.assertEqual(e.kwargs['qnames'], [n2, n1]) self.assertTrue(('responses' in e.kwargs)) - self.assertTrue((e.kwargs['responses'] == {})) + self.assertEqual(e.kwargs['responses'], {}) try: raise dns.resolver.NXDOMAIN(qnames=[n1], responses=['r1.1']) @@ -356,13 +356,13 @@ class NXDOMAINExceptionTestCase(unittest.TestCase): 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.assertTrue((e.args == (MSG,)), repr(e.args)) + self.assertEqual(e.args, (MSG,), repr(e.args)) self.assertTrue(('kwargs' in dir(e))) - self.assertTrue((str(e) == MSG), str(e)) + self.assertEqual(str(e), MSG, str(e)) self.assertTrue(('qnames' in e.kwargs)) - self.assertTrue((e.kwargs['qnames'] == [n1])) + self.assertEqual(e.kwargs['qnames'], [n1]) self.assertTrue(('responses' in e.kwargs)) - self.assertTrue((e.kwargs['responses'] == {n1: 'r1.1'})) + self.assertEqual(e.kwargs['responses'], {n1: 'r1.1'}) def test_nxdomain_merge(self): n1 = dns.name.Name(('a', 'b', '')) @@ -378,7 +378,8 @@ class NXDOMAINExceptionTestCase(unittest.TestCase): e2 = dns.resolver.NXDOMAIN(qnames=qnames2, responses=responses2) e = e1 + e0 + e2 self.assertRaises(AttributeError, lambda: e0 + e0) - self.assertTrue(e.kwargs['qnames'] == [n1, n4, n3], repr(e.kwargs['qnames'])) + 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.')) @@ -399,9 +400,9 @@ class NXDOMAINExceptionTestCase(unittest.TestCase): e1 = dns.resolver.NXDOMAIN(qnames=[qname0, qname1, qname2], responses=responses) e2 = dns.resolver.NXDOMAIN(qnames=[qname0, qname2, qname1], responses=responses) self.assertRaises(TypeError, lambda: eX.canonical_name) - self.assertTrue(e0.canonical_name == qname0) - self.assertTrue(e1.canonical_name == dns.name.from_text(cname1)) - self.assertTrue(e2.canonical_name == dns.name.from_text(cname2)) + self.assertEqual(e0.canonical_name, qname0) + self.assertEqual(e1.canonical_name, dns.name.from_text(cname1)) + self.assertEqual(e2.canonical_name, dns.name.from_text(cname2)) class ResolverNameserverValidTypeTestCase(unittest.TestCase): diff --git a/tests/test_rrset.py b/tests/test_rrset.py index e6a69f8d..638dff37 100644 --- a/tests/test_rrset.py +++ b/tests/test_rrset.py @@ -24,33 +24,33 @@ 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') - self.assertTrue(r1 == r2) + 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') - self.assertTrue(r1 == r2) + 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') - self.assertTrue(r1 != r2) + 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') - self.assertTrue(r1 != r2) + 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') - self.assertTrue(r1 != r2) + 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') - self.assertTrue(r1 != r2) + self.assertNotEqual(r1, r2) if __name__ == '__main__': unittest.main() diff --git a/tests/test_set.py b/tests/test_set.py index 127c9801..08d3997f 100644 --- a/tests/test_set.py +++ b/tests/test_set.py @@ -26,81 +26,81 @@ class SimpleSetTestCase(unittest.TestCase): def testLen1(self): s1 = S() - self.assertTrue(len(s1) == 0) + self.assertEqual(len(s1), 0) def testLen2(self): s1 = S([1, 2, 3]) - self.assertTrue(len(s1) == 3) + self.assertEqual(len(s1), 3) def testLen3(self): s1 = S([1, 2, 3, 3, 3]) - self.assertTrue(len(s1) == 3) + self.assertEqual(len(s1), 3) def testUnion1(self): s1 = S([1, 2, 3]) s2 = S([1, 2, 3]) e = S([1, 2, 3]) - self.assertTrue(s1 | s2 == e) + self.assertEqual(s1 | s2, e) def testUnion2(self): s1 = S([1, 2, 3]) s2 = S([]) e = S([1, 2, 3]) - self.assertTrue(s1 | s2 == e) + self.assertEqual(s1 | s2, e) def testUnion3(self): s1 = S([1, 2, 3]) s2 = S([3, 4]) e = S([1, 2, 3, 4]) - self.assertTrue(s1 | s2 == e) + self.assertEqual(s1 | s2, e) def testIntersection1(self): s1 = S([1, 2, 3]) s2 = S([1, 2, 3]) e = S([1, 2, 3]) - self.assertTrue(s1 & s2 == e) + self.assertEqual(s1 & s2, e) def testIntersection2(self): s1 = S([0, 1, 2, 3]) s2 = S([1, 2, 3, 4]) e = S([1, 2, 3]) - self.assertTrue(s1 & s2 == e) + self.assertEqual(s1 & s2, e) def testIntersection3(self): s1 = S([1, 2, 3]) s2 = S([]) e = S([]) - self.assertTrue(s1 & s2 == e) + self.assertEqual(s1 & s2, e) def testIntersection4(self): s1 = S([1, 2, 3]) s2 = S([5, 4]) e = S([]) - self.assertTrue(s1 & s2 == e) + self.assertEqual(s1 & s2, e) def testDifference1(self): s1 = S([1, 2, 3]) s2 = S([5, 4]) e = S([1, 2, 3]) - self.assertTrue(s1 - s2 == e) + self.assertEqual(s1 - s2, e) def testDifference2(self): s1 = S([1, 2, 3]) s2 = S([]) e = S([1, 2, 3]) - self.assertTrue(s1 - s2 == e) + self.assertEqual(s1 - s2, e) def testDifference3(self): s1 = S([1, 2, 3]) s2 = S([3, 2]) e = S([1]) - self.assertTrue(s1 - s2 == e) + self.assertEqual(s1 - s2, e) def testDifference4(self): s1 = S([1, 2, 3]) s2 = S([3, 2, 1]) e = S([]) - self.assertTrue(s1 - s2 == e) + self.assertEqual(s1 - s2, e) def testSubset1(self): s1 = S([1, 2, 3]) @@ -165,14 +165,14 @@ class SimpleSetTestCase(unittest.TestCase): u = (4, 5, 6) e = S([1, 2, 3, 4, 5, 6]) s1.update(u) - self.assertTrue(s1 == e) + self.assertEqual(s1, e) def testUpdate2(self): s1 = S([1, 2, 3]) u = [] e = S([1, 2, 3]) s1.update(u) - self.assertTrue(s1 == e) + self.assertEqual(s1, e) def testGetitem(self): s1 = S([1, 2, 3]) @@ -180,16 +180,16 @@ class SimpleSetTestCase(unittest.TestCase): i1 = s1[1] i2 = s1[2] s2 = S([i0, i1, i2]) - self.assertTrue(s1 == s2) + self.assertEqual(s1, s2) def testGetslice(self): s1 = S([1, 2, 3]) slice = s1[0:2] - self.assertTrue(len(slice) == 2) + self.assertEqual(len(slice), 2) item = s1[2] slice.append(item) s2 = S(slice) - self.assertTrue(s1 == s2) + self.assertEqual(s1, s2) def testDelitem(self): s1 = S([1, 2, 3]) diff --git a/tests/test_tokenizer.py b/tests/test_tokenizer.py index 630a095c..7fe7f85f 100644 --- a/tests/test_tokenizer.py +++ b/tests/test_tokenizer.py @@ -27,27 +27,27 @@ class TokenizerTestCase(unittest.TestCase): def testStr(self): tok = dns.tokenizer.Tokenizer('foo') token = tok.get() - self.assertTrue(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.assertTrue(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.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, '')) + self.assertEqual(token, Token(dns.tokenizer.QUOTED_STRING, '')) def testQuotedString3(self): tok = dns.tokenizer.Tokenizer(r'"\"foo\""') token = tok.get() - self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, '"foo"')) + self.assertEqual(token, Token(dns.tokenizer.QUOTED_STRING, '"foo"')) def testQuotedString4(self): tok = dns.tokenizer.Tokenizer(r'"foo\010bar"') token = tok.get() - self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, 'foo\x0abar')) + self.assertEqual(token, Token(dns.tokenizer.QUOTED_STRING, 'foo\x0abar')) def testQuotedString5(self): def bad(): @@ -103,28 +103,28 @@ class TokenizerTestCase(unittest.TestCase): tok = dns.tokenizer.Tokenizer(' ;foo\n') token1 = tok.get(want_comment=True) token2 = tok.get() - self.assertTrue(token1 == Token(dns.tokenizer.COMMENT, 'foo') and - token2.is_eol()) + self.assertEqual(token1, Token(dns.tokenizer.COMMENT, 'foo')) + self.assertTrue(token2.is_eol()) def testComment3(self): tok = dns.tokenizer.Tokenizer(' ;foo bar\n') token1 = tok.get(want_comment=True) token2 = tok.get() - self.assertTrue(token1 == Token(dns.tokenizer.COMMENT, 'foo bar') and - token2.is_eol()) + 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)') tokens = list(iter(tok)) - self.assertTrue(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') tokens = list(iter(tok)) - self.assertTrue(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): def bad(): tok = dns.tokenizer.Tokenizer('foo)') @@ -142,8 +142,9 @@ class TokenizerTestCase(unittest.TestCase): t1 = tok.get() tok.unget(t1) t2 = tok.get() - self.assertTrue(t1 == t2 and t1.ttype == dns.tokenizer.IDENTIFIER and \ - t1.value == 'foo') + self.assertEqual(t1, t2) + self.assertEqual(t1.ttype, dns.tokenizer.IDENTIFIER) + self.assertEqual(t1.value, 'foo') def testUnget2(self): def bad(): @@ -156,42 +157,48 @@ class TokenizerTestCase(unittest.TestCase): def testGetEOL1(self): tok = dns.tokenizer.Tokenizer('\n') t = tok.get_eol() - self.assertTrue(t == '\n') + self.assertEqual(t, '\n') def testGetEOL2(self): tok = dns.tokenizer.Tokenizer('') t = tok.get_eol() - self.assertTrue(t == '') + self.assertEqual(t, '') def testEscapedDelimiter1(self): tok = dns.tokenizer.Tokenizer(r'ch\ ld') t = tok.get() - self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\ ld') + self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER) + self.assertEqual(t.value, r'ch\ ld') def testEscapedDelimiter2(self): tok = dns.tokenizer.Tokenizer(r'ch\032ld') t = tok.get() - self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\032ld') + self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER) + self.assertEqual(t.value, r'ch\032ld') def testEscapedDelimiter3(self): tok = dns.tokenizer.Tokenizer(r'ch\ild') t = tok.get() - self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\ild') + self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER) + self.assertEqual(t.value, r'ch\ild') def testEscapedDelimiter1u(self): tok = dns.tokenizer.Tokenizer(r'ch\ ld') t = tok.get().unescape() - self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch ld') + self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER) + self.assertEqual(t.value, r'ch ld') def testEscapedDelimiter2u(self): tok = dns.tokenizer.Tokenizer(r'ch\032ld') t = tok.get().unescape() - self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == 'ch ld') + self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER) + self.assertEqual(t.value, 'ch ld') def testEscapedDelimiter3u(self): tok = dns.tokenizer.Tokenizer(r'ch\ild') t = tok.get().unescape() - self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'child') + self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER) + self.assertEqual(t.value, r'child') if __name__ == '__main__': unittest.main() diff --git a/tests/test_update.py b/tests/test_update.py index 73e7acb3..b2c4767d 100644 --- a/tests/test_update.py +++ b/tests/test_update.py @@ -75,7 +75,7 @@ class UpdateTestCase(unittest.TestCase): update.delete('bar', 'a', '10.0.0.4') update.delete('blaz', 'a') update.delete('blaz2') - self.assertTrue(update.to_wire() == goodwire) + self.assertEqual(update.to_wire(), goodwire) def test_to_wire2(self): # type: () -> None update = dns.update.Update('example') @@ -90,7 +90,7 @@ class UpdateTestCase(unittest.TestCase): update.delete('bar', 'a', '10.0.0.4') update.delete('blaz', 'a') update.delete('blaz2') - self.assertTrue(update.to_wire() == goodwire) + self.assertEqual(update.to_wire(), goodwire) def test_to_wire3(self): # type: () -> None update = dns.update.Update('example') @@ -105,13 +105,13 @@ class UpdateTestCase(unittest.TestCase): update.delete('bar', 'a', '10.0.0.4') update.delete('blaz', 'a') update.delete('blaz2') - self.assertTrue(update.to_wire() == goodwire) + self.assertEqual(update.to_wire(), goodwire) def test_from_text1(self): # type: () -> None update = dns.message.from_text(update_text) w = update.to_wire(origin=dns.name.from_text('example'), want_shuffle=False) - self.assertTrue(w == goodwire) + self.assertEqual(w, goodwire) if __name__ == '__main__': unittest.main() diff --git a/tests/test_zone.py b/tests/test_zone.py index b26159b8..0fae7047 100644 --- a/tests/test_zone.py +++ b/tests/test_zone.py @@ -258,37 +258,37 @@ class ZoneTestCase(unittest.TestCase): rd2 = dns.rdata.from_wire(rds.rdclass, rds.rdtype, wire, 0, len(wire), origin=o) - self.assertTrue(rd == rd2) + self.assertEqual(rd, rd2) def testEqual(self): # type: () -> None z1 = dns.zone.from_text(example_text, 'example.', relativize=True) z2 = dns.zone.from_text(example_text_output, 'example.', relativize=True) - self.assertTrue(z1 == z2) + self.assertEqual(z1, z2) def testNotEqual1(self): # type: () -> None z1 = dns.zone.from_text(example_text, 'example.', relativize=True) z2 = dns.zone.from_text(something_quite_similar, 'example.', relativize=True) - self.assertTrue(z1 != z2) + self.assertNotEqual(z1, z2) def testNotEqual2(self): # type: () -> None z1 = dns.zone.from_text(example_text, 'example.', relativize=True) z2 = dns.zone.from_text(something_different, 'example.', relativize=True) - self.assertTrue(z1 != z2) + self.assertNotEqual(z1, z2) def testNotEqual3(self): # type: () -> None z1 = dns.zone.from_text(example_text, 'example.', relativize=True) z2 = dns.zone.from_text(something_different, 'example2.', relativize=True) - self.assertTrue(z1 != z2) + self.assertNotEqual(z1, z2) def testFindRdataset1(self): # type: () -> None 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.assertTrue(rds == exrds) + self.assertEqual(rds, exrds) def testFindRdataset2(self): # type: () -> None def bad(): # type: () -> None @@ -300,7 +300,7 @@ class ZoneTestCase(unittest.TestCase): 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.assertTrue(rrs == exrrs) + self.assertEqual(rrs, exrrs) def testFindRRset2(self): # type: () -> None def bad(): # type: () -> None @@ -312,7 +312,7 @@ class ZoneTestCase(unittest.TestCase): 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.assertTrue(rds == exrds) + self.assertEqual(rds, exrds) def testGetRdataset2(self): # type: () -> None z = dns.zone.from_text(example_text, 'example.', relativize=True) @@ -323,7 +323,7 @@ class ZoneTestCase(unittest.TestCase): 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.assertTrue(rrs == exrrs) + self.assertEqual(rrs, exrrs) def testGetRRset2(self): # type: () -> None z = dns.zone.from_text(example_text, 'example.', relativize=True) @@ -361,7 +361,7 @@ class ZoneTestCase(unittest.TestCase): 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.assertTrue(rds == exrds) + self.assertEqual(rds, exrds) def testNodeFindRdataset2(self): # type: () -> None def bad(): # type: () -> None @@ -375,7 +375,7 @@ class ZoneTestCase(unittest.TestCase): 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.assertTrue(rds == exrds) + self.assertEqual(rds, exrds) def testNodeGetRdataset2(self): # type: () -> None z = dns.zone.from_text(example_text, 'example.', relativize=True) @@ -401,18 +401,18 @@ class ZoneTestCase(unittest.TestCase): z = dns.zone.from_text(example_text, 'example.', relativize=True) ns = [n for n, r in z.iterate_rdatasets('A')] ns.sort() - self.assertTrue(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): # type: () -> None z = dns.zone.from_text(example_text, 'example.', relativize=True) ns = [n for n, r in z.iterate_rdatasets()] ns.sort() - self.assertTrue(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): # type: () -> None z = dns.zone.from_text(example_text, 'example.', relativize=True) @@ -426,7 +426,7 @@ class ZoneTestCase(unittest.TestCase): 3600, dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, '10.0.0.2'))] - self.assertTrue(l == exl) + self.assertEqual(l, exl) def testIterateAllRdatas(self): # type: () -> None z = dns.zone.from_text(example_text, 'example.', relativize=True) @@ -457,44 +457,44 @@ class ZoneTestCase(unittest.TestCase): dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, '10.0.0.2'))] exl.sort(key=_rdata_sort) - self.assertTrue(l == exl) + self.assertEqual(l, exl) def testTTLs(self): # type: () -> None 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.assertTrue(rds.ttl == 3600) + self.assertEqual(rds.ttl, 3600) n = z['ns1'] rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)) - self.assertTrue(rds.ttl == 86401) + self.assertEqual(rds.ttl, 86401) n = z['ns2'] rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)) - self.assertTrue(rds.ttl == 694861) + self.assertEqual(rds.ttl, 694861) def testTTLFromSOA(self): # type: () -> None 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.assertTrue(rds.ttl == 3600) + 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)) - self.assertTrue(rds.ttl == 694861) + self.assertEqual(rds.ttl, 694861) n = z['ns2'] rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)) - self.assertTrue(rds.ttl == soa_rd.minimum) + self.assertEqual(rds.ttl, soa_rd.minimum) def testTTLFromLast(self): # type: () -> None 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.assertTrue(rds.ttl == 3600) + self.assertEqual(rds.ttl, 3600) n = z['ns1'] rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)) - self.assertTrue(rds.ttl == 3600) + self.assertEqual(rds.ttl, 3600) n = z['ns2'] rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)) - self.assertTrue(rds.ttl == 694861) + self.assertEqual(rds.ttl, 694861) def testNoTTL(self): # type: () -> None def bad(): # type: () -> None @@ -515,7 +515,7 @@ class ZoneTestCase(unittest.TestCase): z1 = dns.zone.from_text(include_text, 'example.', relativize=True, allow_include=True) z2 = dns.zone.from_file(here('example'), 'example.', relativize=True) - self.assertTrue(z1 == z2) + self.assertEqual(z1, z2) def testBadDirective(self): # type: () -> None def bad(): # type: () -> None @@ -528,11 +528,11 @@ class ZoneTestCase(unittest.TestCase): check_origin=False) n = z['@'] rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A)) - self.assertTrue(rds.ttl == 300) + self.assertEqual(rds.ttl, 300) def testZoneOrigin(self): # type: () -> None z = dns.zone.Zone('example.') - self.assertTrue(z.origin == dns.name.from_text('example.')) + self.assertEqual(z.origin, dns.name.from_text('example.')) def bad1(): # type: () -> None o = dns.name.from_text('example', None) dns.zone.Zone(o)