From: Thomas A Caswell Date: Wed, 30 Oct 2019 23:57:57 +0000 (-0400) Subject: TST: fix failUnlessRaises -> assertRaises deprecation X-Git-Tag: v2.0.0rc1~346^2~3 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=6c6fe87aa5c9c86be157cae3efb132fe48875ea4;p=thirdparty%2Fdnspython.git TST: fix failUnlessRaises -> assertRaises deprecation failUnlessRaises was deprecated in py31 --- diff --git a/tests/test_bugs.py b/tests/test_bugs.py index e94e4039..e7a3193a 100644 --- a/tests/test_bugs.py +++ b/tests/test_bugs.py @@ -44,7 +44,7 @@ class BugsTestCase(unittest.TestCase): def test_TTL_bounds_check(self): def bad(): dns.ttl.from_text("2147483648") - self.failUnlessRaises(dns.ttl.BadTTL, bad) + self.assertRaises(dns.ttl.BadTTL, bad) def test_empty_NSEC3_window(self): rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NSEC3, diff --git a/tests/test_dnssec.py b/tests/test_dnssec.py index d581f9ad..24492103 100644 --- a/tests/test_dnssec.py +++ b/tests/test_dnssec.py @@ -164,7 +164,7 @@ class DNSSECValidatorTestCase(unittest.TestCase): def bad(): # type: () -> None dns.dnssec.validate(abs_other_soa, abs_soa_rrsig, abs_keys, None, when) - self.failUnlessRaises(dns.dnssec.ValidationFailure, bad) + self.assertRaises(dns.dnssec.ValidationFailure, bad) def testRelativeRSAGood(self): # type: () -> None dns.dnssec.validate(rel_soa, rel_soa_rrsig, rel_keys, @@ -174,7 +174,7 @@ class DNSSECValidatorTestCase(unittest.TestCase): def bad(): # type: () -> None dns.dnssec.validate(rel_other_soa, rel_soa_rrsig, rel_keys, abs_dnspython_org, when) - self.failUnlessRaises(dns.dnssec.ValidationFailure, bad) + 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, @@ -184,7 +184,7 @@ class DNSSECValidatorTestCase(unittest.TestCase): def bad(): # type: () -> None dns.dnssec.validate(abs_other_dsa_soa, abs_dsa_soa_rrsig, abs_dsa_keys, None, when2) - self.failUnlessRaises(dns.dnssec.ValidationFailure, bad) + self.assertRaises(dns.dnssec.ValidationFailure, bad) @unittest.skipUnless(dns.dnssec._have_ecdsa, "python ECDSA cannot be imported") @@ -198,7 +198,7 @@ class DNSSECValidatorTestCase(unittest.TestCase): def bad(): # type: () -> None dns.dnssec.validate(abs_other_ecdsa256_soa, abs_ecdsa256_soa_rrsig, abs_ecdsa256_keys, None, when3) - self.failUnlessRaises(dns.dnssec.ValidationFailure, bad) + self.assertRaises(dns.dnssec.ValidationFailure, bad) @unittest.skipUnless(dns.dnssec._have_ecdsa, "python ECDSA cannot be imported") @@ -212,7 +212,7 @@ class DNSSECValidatorTestCase(unittest.TestCase): def bad(): # type: () -> None dns.dnssec.validate(abs_other_ecdsa384_soa, abs_ecdsa384_soa_rrsig, abs_ecdsa384_keys, None, when4) - self.failUnlessRaises(dns.dnssec.ValidationFailure, bad) + self.assertRaises(dns.dnssec.ValidationFailure, bad) class DNSSECMakeDSTestCase(unittest.TestCase): diff --git a/tests/test_flags.py b/tests/test_flags.py index 132869da..20c200d1 100644 --- a/tests/test_flags.py +++ b/tests/test_flags.py @@ -46,7 +46,7 @@ class FlagsTestCase(unittest.TestCase): def test_rcode8(self): def bad(): dns.rcode.to_flags(4096) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_flags1(self): self.assertTrue(dns.flags.from_text("RA RD AA QR") == \ diff --git a/tests/test_generate.py b/tests/test_generate.py index d0ca19c8..bcd116b9 100644 --- a/tests/test_generate.py +++ b/tests/test_generate.py @@ -151,12 +151,12 @@ class GenerateTestCase(unittest.TestCase): def testFromText(self): # type: () -> None def bad(): # type: () -> None dns.zone.from_text(example_text, 'example.', relativize=True) - self.failUnlessRaises(dns.zone.NoSOA, bad) + self.assertRaises(dns.zone.NoSOA, bad) def testFromText1(self): # type: () -> None def bad(): # type: () -> None dns.zone.from_text(example_text1, 'example.', relativize=True) - self.failUnlessRaises(dns.zone.NoSOA, bad) + self.assertRaises(dns.zone.NoSOA, bad) def testIterateAllRdatas2(self): # type: () -> None z = dns.zone.from_text(example_text2, 'example.', relativize=True) diff --git a/tests/test_message.py b/tests/test_message.py index 8de668c4..34512f00 100644 --- a/tests/test_message.py +++ b/tests/test_message.py @@ -142,7 +142,7 @@ class MessageTestCase(unittest.TestCase): '10.0.0.%d' % i) q.additional.append(rrset) q.to_wire(max_size=512) - self.failUnlessRaises(dns.exception.TooBig, bad) + self.assertRaises(dns.exception.TooBig, bad) def test_answer1(self): a = dns.message.from_text(answer_text) @@ -153,20 +153,20 @@ class MessageTestCase(unittest.TestCase): def bad(): badwire = goodwire + b'\x00' dns.message.from_wire(badwire) - self.failUnlessRaises(dns.message.TrailingJunk, bad) + self.assertRaises(dns.message.TrailingJunk, bad) def test_ShortHeader(self): def bad(): badwire = b'\x00' * 11 dns.message.from_wire(badwire) - self.failUnlessRaises(dns.message.ShortHeader, bad) + self.assertRaises(dns.message.ShortHeader, bad) def test_RespondingToResponse(self): def bad(): q = dns.message.make_query('foo', 'A') r1 = dns.message.make_response(q) dns.message.make_response(r1) - self.failUnlessRaises(dns.exception.FormError, bad) + self.assertRaises(dns.exception.FormError, bad) def test_ExtendedRcodeSetting(self): m = dns.message.make_query('foo', 'A') @@ -214,7 +214,7 @@ class MessageTestCase(unittest.TestCase): a.flags |= dns.flags.TC wire = a.to_wire(want_shuffle=False) dns.message.from_wire(wire) - self.failUnlessRaises(dns.message.Truncated, bad) + self.assertRaises(dns.message.Truncated, bad) def test_MessyTruncated(self): def bad(): @@ -222,7 +222,7 @@ class MessageTestCase(unittest.TestCase): a.flags |= dns.flags.TC wire = a.to_wire(want_shuffle=False) dns.message.from_wire(wire[:-3]) - self.failUnlessRaises(dns.message.Truncated, bad) + self.assertRaises(dns.message.Truncated, bad) if __name__ == '__main__': unittest.main() diff --git a/tests/test_name.py b/tests/test_name.py index ccbc532e..8a020150 100644 --- a/tests/test_name.py +++ b/tests/test_name.py @@ -101,12 +101,12 @@ class NameTestCase(unittest.TestCase): def testImmutable1(self): def bad(): self.origin.labels = () - self.failUnlessRaises(TypeError, bad) + self.assertRaises(TypeError, bad) def testImmutable2(self): def bad(): self.origin.labels[0] = 'foo' - self.failUnlessRaises(TypeError, bad) + self.assertRaises(TypeError, bad) def testAbs1(self): self.assertTrue(dns.name.root.is_absolute()) @@ -290,12 +290,12 @@ class NameTestCase(unittest.TestCase): def testEmptyLabel1(self): def bad(): dns.name.Name(['a', '', 'b']) - self.failUnlessRaises(dns.name.EmptyLabel, bad) + self.assertRaises(dns.name.EmptyLabel, bad) def testEmptyLabel2(self): def bad(): dns.name.Name(['', 'b']) - self.failUnlessRaises(dns.name.EmptyLabel, bad) + self.assertRaises(dns.name.EmptyLabel, bad) def testEmptyLabel3(self): n = dns.name.Name(['b', '']) @@ -308,7 +308,7 @@ class NameTestCase(unittest.TestCase): def testLabelTooLong(self): def bad(): dns.name.Name(['a' * 64, 'b']) - self.failUnlessRaises(dns.name.LabelTooLong, bad) + self.assertRaises(dns.name.LabelTooLong, bad) def testLongName(self): n = dns.name.Name(['a' * 63, 'a' * 63, 'a' * 63, 'a' * 62]) @@ -317,7 +317,7 @@ class NameTestCase(unittest.TestCase): def testNameTooLong(self): def bad(): dns.name.Name(['a' * 63, 'a' * 63, 'a' * 63, 'a' * 63]) - self.failUnlessRaises(dns.name.NameTooLong, bad) + self.assertRaises(dns.name.NameTooLong, bad) def testConcat1(self): n1 = dns.name.Name(['a', 'b']) @@ -359,13 +359,13 @@ class NameTestCase(unittest.TestCase): n1 = dns.name.Name(['a', 'b', '']) n2 = dns.name.Name(['c']) return n1 + n2 - self.failUnlessRaises(dns.name.AbsoluteConcatenation, bad) + self.assertRaises(dns.name.AbsoluteConcatenation, bad) def testBadEscape(self): def bad(): n = dns.name.from_text(r'a.b\0q1.c.') print(n) - self.failUnlessRaises(dns.name.BadEscape, bad) + self.assertRaises(dns.name.BadEscape, bad) def testDigestable1(self): n = dns.name.from_text('FOO.bar') @@ -392,7 +392,7 @@ class NameTestCase(unittest.TestCase): def bad(): n = dns.name.from_text('FOO.bar', None) n.to_digestable() - self.failUnlessRaises(dns.name.NeedAbsoluteNameOrOrigin, bad) + self.assertRaises(dns.name.NeedAbsoluteNameOrOrigin, bad) def testToWire1(self): n = dns.name.from_text('FOO.bar') @@ -448,7 +448,7 @@ class NameTestCase(unittest.TestCase): f = BytesIO() compress = {} # type: Dict[dns.name.Name,int] n.to_wire(f, compress) - self.failUnlessRaises(dns.name.NeedAbsoluteNameOrOrigin, bad) + self.assertRaises(dns.name.NeedAbsoluteNameOrOrigin, bad) def testSplit1(self): n = dns.name.from_text('foo.bar.') @@ -482,13 +482,13 @@ class NameTestCase(unittest.TestCase): def bad(): n = dns.name.from_text('foo.bar.') n.split(-1) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def testBadSplit2(self): def bad(): n = dns.name.from_text('foo.bar.') n.split(4) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def testRelativize1(self): n = dns.name.from_text('a.foo.bar.', None) @@ -607,25 +607,25 @@ class NameTestCase(unittest.TestCase): def bad(): w = b'\x03foo\xc0\x04' dns.name.from_wire(w, 0) - self.failUnlessRaises(dns.name.BadPointer, bad) + self.assertRaises(dns.name.BadPointer, bad) def testBadFromWire2(self): def bad(): w = b'\x03foo\xc0\x05' dns.name.from_wire(w, 0) - self.failUnlessRaises(dns.name.BadPointer, bad) + self.assertRaises(dns.name.BadPointer, bad) def testBadFromWire3(self): def bad(): w = b'\xbffoo' dns.name.from_wire(w, 0) - self.failUnlessRaises(dns.name.BadLabelType, bad) + self.assertRaises(dns.name.BadLabelType, bad) def testBadFromWire4(self): def bad(): w = b'\x41foo' dns.name.from_wire(w, 0) - self.failUnlessRaises(dns.name.BadLabelType, bad) + self.assertRaises(dns.name.BadLabelType, bad) def testParent1(self): n = dns.name.from_text('foo.bar.') @@ -641,13 +641,13 @@ class NameTestCase(unittest.TestCase): def bad(): n = dns.name.root n.parent() - self.failUnlessRaises(dns.name.NoParent, bad) + self.assertRaises(dns.name.NoParent, bad) def testParent4(self): def bad(): n = dns.name.empty n.parent() - self.failUnlessRaises(dns.name.NoParent, bad) + self.assertRaises(dns.name.NoParent, bad) def testFromUnicode1(self): n = dns.name.from_text('foo.bar') @@ -701,7 +701,7 @@ class NameTestCase(unittest.TestCase): def bad(): codec = dns.name.IDNA_2008_Strict return dns.name.from_unicode(t, idna_codec=codec) - self.failUnlessRaises(dns.name.IDNAException, bad) + 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.') c2 = dns.name.IDNA_2008_Transitional @@ -725,9 +725,9 @@ class NameTestCase(unittest.TestCase): def bad3(): codec = dns.name.IDNA_2008_Transitional return dns.name.from_unicode(t, idna_codec=codec) - self.failUnlessRaises(dns.name.IDNAException, bad1) - self.failUnlessRaises(dns.name.IDNAException, bad2) - self.failUnlessRaises(dns.name.IDNAException, bad3) + 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.') @@ -768,7 +768,7 @@ class NameTestCase(unittest.TestCase): def bad(): # This throws in IDNA2003 because it doesn't "round trip". n.to_unicode(idna_codec=dns.name.IDNA_2003_Strict) - self.failUnlessRaises(dns.name.IDNAException, bad) + self.assertRaises(dns.name.IDNAException, bad) def testReverseIPv4(self): e = dns.name.from_text('1.0.0.127.in-addr.arpa.') @@ -788,12 +788,12 @@ class NameTestCase(unittest.TestCase): def testBadReverseIPv4(self): def bad(): dns.reversename.from_address('127.0.foo.1') - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def testBadReverseIPv6(self): def bad(): dns.reversename.from_address('::1::1') - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def testForwardIPv4(self): n = dns.name.from_text('1.0.0.127.in-addr.arpa.') diff --git a/tests/test_namedict.py b/tests/test_namedict.py index c671d6f1..97a5252a 100644 --- a/tests/test_namedict.py +++ b/tests/test_namedict.py @@ -57,12 +57,12 @@ class NameTestCase(unittest.TestCase): def bad(): n = dns.name.from_text('a.b.c.') self.ndict.get_deepest_match(n) - self.failUnlessRaises(KeyError, bad) + self.assertRaises(KeyError, bad) def testLookup6(self): def bad(): self.ndict.get_deepest_match(dns.name.empty) - self.failUnlessRaises(KeyError, bad) + self.assertRaises(KeyError, bad) def testLookup7(self): self.ndict[dns.name.empty] = 100 @@ -73,7 +73,7 @@ class NameTestCase(unittest.TestCase): def testLookup8(self): def bad(): self.ndict['foo'] = 100 - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def testRelDepth(self): self.assertTrue(self.rndict.max_depth == 2) diff --git a/tests/test_ntoaaton.py b/tests/test_ntoaaton.py index f345275c..763c1be8 100644 --- a/tests/test_ntoaaton.py +++ b/tests/test_ntoaaton.py @@ -61,17 +61,17 @@ class NtoAAtoNTestCase(unittest.TestCase): def test_bad_aton1(self): def bad(): aton6('abcd:dcba') - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def test_bad_aton2(self): def bad(): aton6('abcd::dcba::1') - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def test_bad_aton3(self): def bad(): aton6('1:2:3:4:5:6:7:8:9') - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def test_aton6(self): a = aton6('::') @@ -162,12 +162,12 @@ class NtoAAtoNTestCase(unittest.TestCase): def test_bad_ntoa1(self): def bad(): ntoa6('') - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_bad_ntoa2(self): def bad(): ntoa6('\x00' * 17) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_good_v4_aton(self): pairs = [('1.2.3.4', b'\x01\x02\x03\x04'), @@ -186,7 +186,7 @@ class NtoAAtoNTestCase(unittest.TestCase): return bad for addr in v4_bad_addrs: print(addr) - self.failUnlessRaises(dns.exception.SyntaxError, make_bad(addr)) + 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', @@ -198,7 +198,7 @@ class NtoAAtoNTestCase(unittest.TestCase): x = aton6(a) return bad for addr in addrs: - self.failUnlessRaises(dns.exception.SyntaxError, make_bad(addr)) + 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' diff --git a/tests/test_rdata.py b/tests/test_rdata.py index 4e3f49da..43e1a673 100644 --- a/tests/test_rdata.py +++ b/tests/test_rdata.py @@ -45,7 +45,7 @@ class RdataTestCase(unittest.TestCase): def bad(): TTXTTWO = dns.rdatatype.TXT dns.rdata.register_type(tests.ttxt_module, TTXTTWO, 'TTXTTWO') - self.failUnlessRaises(dns.rdata.RdatatypeExists, bad) + self.assertRaises(dns.rdata.RdatatypeExists, bad) if __name__ == '__main__': unittest.main() diff --git a/tests/test_rdtypeandclass.py b/tests/test_rdtypeandclass.py index b911c13c..fd696d20 100644 --- a/tests/test_rdtypeandclass.py +++ b/tests/test_rdtypeandclass.py @@ -44,12 +44,12 @@ class RdTypeAndClassTestCase(unittest.TestCase): def test_class_bytext_bounds2(self): def bad(): dns.rdataclass.from_text('CLASS65536') - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_class_bytext_unknown(self): def bad(): dns.rdataclass.from_text('XXX') - self.failUnlessRaises(dns.rdataclass.UnknownRdataclass, bad) + self.assertRaises(dns.rdataclass.UnknownRdataclass, bad) def test_class_totext1(self): self.assertTrue(dns.rdataclass.to_text(dns.rdataclass.IN) == 'IN') @@ -60,12 +60,12 @@ class RdTypeAndClassTestCase(unittest.TestCase): def test_class_totext_bounds1(self): def bad(): dns.rdataclass.to_text(-1) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_class_totext_bounds2(self): def bad(): dns.rdataclass.to_text(65536) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) # Types @@ -98,12 +98,12 @@ class RdTypeAndClassTestCase(unittest.TestCase): def test_type_bytext_bounds2(self): def bad(): dns.rdatatype.from_text('TYPE65536') - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_type_bytext_unknown(self): def bad(): dns.rdatatype.from_text('XXX') - self.failUnlessRaises(dns.rdatatype.UnknownRdatatype, bad) + self.assertRaises(dns.rdatatype.UnknownRdatatype, bad) def test_type_totext1(self): self.assertTrue(dns.rdatatype.to_text(dns.rdatatype.A) == 'A') @@ -114,12 +114,12 @@ class RdTypeAndClassTestCase(unittest.TestCase): def test_type_totext_bounds1(self): def bad(): dns.rdatatype.to_text(-1) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_type_totext_bounds2(self): def bad(): dns.rdatatype.to_text(65536) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_type0_totext(self): self.assertTrue(dns.rdatatype.to_text(0) == 'TYPE0') diff --git a/tests/test_rdtypeanydnskey.py b/tests/test_rdtypeanydnskey.py index 70f2e228..967facc5 100644 --- a/tests/test_rdtypeanydnskey.py +++ b/tests/test_rdtypeanydnskey.py @@ -53,7 +53,7 @@ class RdtypeAnyDnskeyTestCase(unittest.TestCase): def testFlagsUnknownToFlags(self): # type: () -> None '''Test that conversion from undefined mnemonic raises error.''' - self.failUnlessRaises(NotImplementedError, + self.assertRaises(NotImplementedError, dns.rdtypes.ANY.DNSKEY.flags_from_text_set, (['0x8000'])) diff --git a/tests/test_resolver.py b/tests/test_resolver.py index f15fdfd1..1f788396 100644 --- a/tests/test_resolver.py +++ b/tests/test_resolver.py @@ -140,7 +140,7 @@ class BaseResolverTests(unittest.TestCase): dns.rdataclass.IN, message, False) return answer[0] - self.failUnlessRaises(IndexError, bad) + self.assertRaises(IndexError, bad) def testIndexErrorOnEmptyRRsetDelete(self): def bad(): @@ -150,7 +150,7 @@ class BaseResolverTests(unittest.TestCase): dns.rdataclass.IN, message, False) del answer[0] - self.failUnlessRaises(IndexError, bad) + self.assertRaises(IndexError, bad) @unittest.skipIf(not _network_available, "Internet not reachable") def testZoneForName1(self): @@ -177,7 +177,7 @@ class BaseResolverTests(unittest.TestCase): def bad(): name = dns.name.from_text('dnspython.org', None) dns.resolver.zone_for_name(name) - self.failUnlessRaises(dns.resolver.NotAbsolute, bad) + self.assertRaises(dns.resolver.NotAbsolute, bad) def testLRUReplace(self): cache = dns.resolver.LRUCache(4) diff --git a/tests/test_tokenizer.py b/tests/test_tokenizer.py index 0075fd09..630a095c 100644 --- a/tests/test_tokenizer.py +++ b/tests/test_tokenizer.py @@ -53,19 +53,19 @@ class TokenizerTestCase(unittest.TestCase): def bad(): tok = dns.tokenizer.Tokenizer(r'"foo') tok.get() - self.failUnlessRaises(dns.exception.UnexpectedEnd, bad) + self.assertRaises(dns.exception.UnexpectedEnd, bad) def testQuotedString6(self): def bad(): tok = dns.tokenizer.Tokenizer(r'"foo\01') tok.get() - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def testQuotedString7(self): def bad(): tok = dns.tokenizer.Tokenizer('"foo\nbar"') tok.get() - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def testEmpty1(self): tok = dns.tokenizer.Tokenizer('') @@ -129,13 +129,13 @@ class TokenizerTestCase(unittest.TestCase): def bad(): tok = dns.tokenizer.Tokenizer('foo)') list(iter(tok)) - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def testMultiline4(self): def bad(): tok = dns.tokenizer.Tokenizer('((foo)') list(iter(tok)) - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def testUnget1(self): tok = dns.tokenizer.Tokenizer('foo') @@ -151,7 +151,7 @@ class TokenizerTestCase(unittest.TestCase): t1 = tok.get() tok.unget(t1) tok.unget(t1) - self.failUnlessRaises(dns.tokenizer.UngetBufferFull, bad) + self.assertRaises(dns.tokenizer.UngetBufferFull, bad) def testGetEOL1(self): tok = dns.tokenizer.Tokenizer('\n') diff --git a/tests/test_zone.py b/tests/test_zone.py index 2893718e..b26159b8 100644 --- a/tests/test_zone.py +++ b/tests/test_zone.py @@ -294,7 +294,7 @@ class ZoneTestCase(unittest.TestCase): def bad(): # type: () -> None z = dns.zone.from_text(example_text, 'example.', relativize=True) z.find_rdataset('@', 'loc') - self.failUnlessRaises(KeyError, bad) + self.assertRaises(KeyError, bad) def testFindRRset1(self): # type: () -> None z = dns.zone.from_text(example_text, 'example.', relativize=True) @@ -306,7 +306,7 @@ class ZoneTestCase(unittest.TestCase): def bad(): # type: () -> None z = dns.zone.from_text(example_text, 'example.', relativize=True) z.find_rrset('@', 'loc') - self.failUnlessRaises(KeyError, bad) + self.assertRaises(KeyError, bad) def testGetRdataset1(self): # type: () -> None z = dns.zone.from_text(example_text, 'example.', relativize=True) @@ -368,7 +368,7 @@ class ZoneTestCase(unittest.TestCase): z = dns.zone.from_text(example_text, 'example.', relativize=True) node = z['@'] node.find_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC) - self.failUnlessRaises(KeyError, bad) + self.assertRaises(KeyError, bad) def testNodeGetRdataset1(self): # type: () -> None z = dns.zone.from_text(example_text, 'example.', relativize=True) @@ -499,17 +499,17 @@ class ZoneTestCase(unittest.TestCase): def testNoTTL(self): # type: () -> None def bad(): # type: () -> None dns.zone.from_text(no_ttl_text, 'example.', check_origin=False) - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def testNoSOA(self): # type: () -> None def bad(): # type: () -> None dns.zone.from_text(no_soa_text, 'example.', relativize=True) - self.failUnlessRaises(dns.zone.NoSOA, bad) + self.assertRaises(dns.zone.NoSOA, bad) def testNoNS(self): # type: () -> None def bad(): # type: () -> None dns.zone.from_text(no_ns_text, 'example.', relativize=True) - self.failUnlessRaises(dns.zone.NoNS, bad) + self.assertRaises(dns.zone.NoNS, bad) def testInclude(self): # type: () -> None z1 = dns.zone.from_text(include_text, 'example.', relativize=True, @@ -520,7 +520,7 @@ class ZoneTestCase(unittest.TestCase): def testBadDirective(self): # type: () -> None def bad(): # type: () -> None dns.zone.from_text(bad_directive_text, 'example.', relativize=True) - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def testFirstRRStartsWithWhitespace(self): # type: () -> None # no name is specified, so default to the initial origin @@ -536,10 +536,10 @@ class ZoneTestCase(unittest.TestCase): def bad1(): # type: () -> None o = dns.name.from_text('example', None) dns.zone.Zone(o) - self.failUnlessRaises(ValueError, bad1) + self.assertRaises(ValueError, bad1) def bad2(): # type: () -> None dns.zone.Zone(cast(str, 1.0)) - self.failUnlessRaises(ValueError, bad2) + self.assertRaises(ValueError, bad2) def testZoneOriginNone(self): # type: () -> None dns.zone.Zone(cast(str, None))