From: Bob Halley Date: Thu, 28 Apr 2011 15:21:29 +0000 (+0100) Subject: merge changes up to py3merge2 tag; update tests to assert style X-Git-Tag: v1.10.0-py3~40 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=95b36ca74ed1c1ec5c473302333b67d50643f48c;p=thirdparty%2Fdnspython.git merge changes up to py3merge2 tag; update tests to assert style --- diff --git a/ChangeLog b/ChangeLog index 6a07424d..94eca92a 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,52 @@ +2011-04-05 Bob Halley + + * Old DNSSEC types (KEY, NXT, and SIG) have been removed. + + * Bounds checking of slices in rdata wire processing is now more + strict, and bounds errors (e.g. we got less data than was + expected) now raise dns.exception.FormError rather than + IndexError. + +2011-03-28 Bob Halley + + * (Version 1.9.4 released) + +2011-03-24 Bob Halley + + * dns/rdata.py (Rdata._wire_cmp): We need to specify no + compression and an origin to _wire_cmp() in case names in the + rdata are relative names. + + * dns/rdtypes/ANY/SIG.py (SIG._cmp): Add missing 'import struct'. + Thanks to Arfrever Frehtes Taifersar Arahesis for reporting the + problem. + +2011-03-24 Bob Halley + + * (Version 1.9.3 released) + +2011-03-22 Bob Halley + + * dns/resolver.py: a boolean parameter, 'raise_on_no_answer', has + been added to the query() methods. In no-error, no-data + situations, this parameter determines whether NoAnswer should be + raised or not. If True, NoAnswer is raised. If False, then an + Answer() object with a None rrset will be returned. + + * dns/resolver.py: Answer() objects now have a canonical_name field. + +2011-01-11 Bob Halley + + * Dnspython was erroneously doing case-insensitive comparisons + of the names in NSEC and RRSIG RRs. Thanks to Casey Deccio for + reporting this bug. + +2010-12-17 Bob Halley + + * dns/message.py (_WireReader._get_section): use "is" and not "==" + when testing what section an RR is in. Thanks to James Raftery + for reporting this bug. + 2010-12-10 Bob Halley * dns/resolver.py (Resolver.query): disallow metaqueries. diff --git a/README b/README index bfc75b22..ae201dc1 100644 --- a/README +++ b/README @@ -22,7 +22,47 @@ development by continuing to employ the author :). ABOUT THIS RELEASE -This is dnspython 1.9.2 +This is dnspython 1.9.5 + +New since 1.9.4: + + XXX TBS. + +Bugs fixed since 1.9.4: + + XXX TBS. + +New since 1.9.3: + + Nothing. + +Bugs fixed since 1.9.3: + + The rdata _wire_cmp() routine now handles relative names. + + The SIG RR implementation was missing 'import struct'. + +New since 1.9.2: + + A boolean parameter, 'raise_on_no_answer', has been added to + the query() methods. In no-error, no-data situations, this + parameter determines whether NoAnswer should be raised or not. + If True, NoAnswer is raised. If False, then an Answer() + object with a None rrset will be returned. + + Resolver Answer() objects now have a canonical_name field. + + Rdata now have a __hash__ method. + +Bugs fixed since 1.9.2: + + Dnspython was erroneously doing case-insensitive comparisons + of the names in NSEC and RRSIG RRs. + + We now use "is" and not "==" when testing what section an RR + is in. + + The resolver now disallows metaqueries. New since 1.9.1: @@ -365,7 +405,7 @@ the prior release. REQUIREMENTS -Python 3.1 or later. +Python 2.4 or later. INSTALLATION diff --git a/dns/__init__.py b/dns/__init__.py index 87370581..851fd68e 100644 --- a/dns/__init__.py +++ b/dns/__init__.py @@ -50,5 +50,6 @@ __all__ = [ 'update', 'util', 'version', + 'wiredata', 'zone', ] diff --git a/dns/message.py b/dns/message.py index ca17e5de..bd904fba 100644 --- a/dns/message.py +++ b/dns/message.py @@ -34,6 +34,7 @@ import dns.rdatatype import dns.rrset import dns.renderer import dns.tsig +import dns.wiredata class ShortHeader(dns.exception.FormError): """Raised if the DNS packet passed to from_wire() is too short.""" @@ -578,7 +579,7 @@ class _WireReader(object): def __init__(self, wire, message, question_only=False, one_rr_per_rrset=False): - self.wire = wire + self.wire = dns.wiredata.maybe_wrap(wire) self.message = message self.current = 0 self.updating = False @@ -687,7 +688,7 @@ class _WireReader(object): deleting = None if deleting == dns.rdataclass.ANY or \ (deleting == dns.rdataclass.NONE and \ - section == self.message.answer): + section is self.message.answer): covers = dns.rdatatype.NONE rd = None else: diff --git a/dns/name.py b/dns/name.py index f58cfc99..fdf68913 100644 --- a/dns/name.py +++ b/dns/name.py @@ -28,6 +28,7 @@ import sys import dns.exception import dns.util +import dns.wiredata NAMERELN_NONE = 0 NAMERELN_SUPERDOMAIN = 1 @@ -637,6 +638,7 @@ def from_wire(message, current): if not isinstance(message, bytes): raise ValueError("input to from_wire() must be a byte string") + message = dns.wiredata.maybe_wrap(message) labels = [] biggest_pointer = current hops = 0 @@ -645,7 +647,7 @@ def from_wire(message, current): cused = 1 while count != 0: if count < 64: - labels.append(message[current : current + count]) + labels.append(message[current : current + count].unwrap()) current += count if hops == 0: cused += count diff --git a/dns/query.py b/dns/query.py index 05651984..c7144915 100644 --- a/dns/query.py +++ b/dns/query.py @@ -66,7 +66,7 @@ def _poll_for(fd, readable, writable, error, timeout): pollable.register(fd, event_mask) if timeout: - event_list = pollable.poll(long(timeout * 1000)) + event_list = pollable.poll(int(timeout * 1000)) else: event_list = pollable.poll() diff --git a/dns/rdata.py b/dns/rdata.py index 1feec760..586c5c3c 100644 --- a/dns/rdata.py +++ b/dns/rdata.py @@ -33,6 +33,7 @@ import dns.name import dns.rdataclass import dns.rdatatype import dns.tokenizer +import dns.wiredata import dns.util _hex_chunksize = 32 @@ -260,6 +261,19 @@ class Rdata(object): def __hash__(self): return hash(self.to_digestable(dns.name.root)) + def _wire_cmp(self, other): + # A number of types compare rdata in wire form, so we provide + # the method here instead of duplicating it. + # + # We specifiy an arbitrary origin of '.' when doing the + # comparison, since the rdata may have relative names and we + # can't convert a relative name to wire without an origin. + b1 = io.BytesIO() + self.to_wire(b1, None, dns.name.root) + b2 = io.BytesIO() + other.to_wire(b2, None, dns.name.root) + return dns.util.cmp(b1.getvalue(), b2.getvalue()) + @classmethod def from_text(cls, rdclass, rdtype, tok, origin = None, relativize = True): """Build an rdata object from text format. @@ -456,5 +470,6 @@ def from_wire(rdclass, rdtype, wire, current, rdlen, origin = None): @type origin: dns.name.Name @rtype: dns.rdata.Rdata instance""" + wire = dns.wiredata.maybe_wrap(wire) cls = get_rdata_class(rdclass, rdtype) return cls.from_wire(rdclass, rdtype, wire, current, rdlen, origin) diff --git a/dns/rdtypes/ANY/CERT.py b/dns/rdtypes/ANY/CERT.py index 675f2f12..ef7d6290 100644 --- a/dns/rdtypes/ANY/CERT.py +++ b/dns/rdtypes/ANY/CERT.py @@ -61,7 +61,7 @@ class CERT(dns.rdata.Rdata): @ivar algorithm: algorithm @type algorithm: int @ivar certificate: the certificate or CRL - @type certificate: string + @type certificate: bytes @see: RFC 2538""" __slots__ = ['certificate_type', 'key_tag', 'algorithm', 'certificate'] @@ -108,13 +108,13 @@ class CERT(dns.rdata.Rdata): file.write(self.certificate) def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None): - prefix = wire[current : current + 5] + prefix = wire[current : current + 5].unwrap() current += 5 rdlen -= 5 if rdlen < 0: raise dns.exception.FormError (certificate_type, key_tag, algorithm) = struct.unpack("!HHB", prefix) - certificate = wire[current : current + rdlen] + certificate = wire[current : current + rdlen].unwrap() return cls(rdclass, rdtype, certificate_type, key_tag, algorithm, certificate) diff --git a/dns/rdtypes/ANY/DNSKEY.py b/dns/rdtypes/ANY/DNSKEY.py index ad66ef0c..33628724 100644 --- a/dns/rdtypes/ANY/DNSKEY.py +++ b/dns/rdtypes/ANY/DNSKEY.py @@ -13,13 +13,81 @@ # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -import dns.rdtypes.keybase +import base64 +import struct + +import dns.exception +import dns.dnssec +import dns.rdata +import dns.util # flag constants SEP = 0x0001 REVOKE = 0x0080 ZONE = 0x0100 -class DNSKEY(dns.rdtypes.keybase.KEYBase): - """DNSKEY record""" - pass +class DNSKEY(dns.rdata.Rdata): + """DNSKEY record + + @ivar flags: the key flags + @type flags: int + @ivar protocol: the protocol for which this key may be used + @type protocol: int + @ivar algorithm: the algorithm used for the key + @type algorithm: int + @ivar key: the public key + @type key: string""" + + __slots__ = ['flags', 'protocol', 'algorithm', 'key'] + + def __init__(self, rdclass, rdtype, flags, protocol, algorithm, key): + super(DNSKEY, self).__init__(rdclass, rdtype) + self.flags = flags + self.protocol = protocol + self.algorithm = algorithm + self.key = key + + def to_text(self, origin=None, relativize=True, **kw): + return '%d %d %d %s' % (self.flags, self.protocol, self.algorithm, + dns.rdata._base64ify(self.key)) + + @classmethod + def from_text(cls, rdclass, rdtype, tok, origin = None, relativize = True): + flags = tok.get_uint16() + protocol = tok.get_uint8() + algorithm = dns.dnssec.algorithm_from_text(tok.get_string()) + chunks = [] + while 1: + t = tok.get().unescape() + if t.is_eol_or_eof(): + break + if not t.is_identifier(): + raise dns.exception.SyntaxError + chunks.append(t.value) + b64 = ''.join(chunks) + key = base64.b64decode(b64.encode('ascii')) + return cls(rdclass, rdtype, flags, protocol, algorithm, key) + + def to_wire(self, file, compress = None, origin = None): + header = struct.pack("!HBB", self.flags, self.protocol, self.algorithm) + file.write(header) + file.write(self.key) + + @classmethod + def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None): + if rdlen < 4: + raise dns.exception.FormError + header = struct.unpack('!HBB', wire[current : current + 4]) + current += 4 + rdlen -= 4 + key = wire[current : current + rdlen].unwrap() + return cls(rdclass, rdtype, header[0], header[1], header[2], + key) + + def _cmp(self, other): + hs = struct.pack("!HBB", self.flags, self.protocol, self.algorithm) + ho = struct.pack("!HBB", other.flags, other.protocol, other.algorithm) + v = dns.util.cmp(hs, ho) + if v == 0: + v = dns.util.cmp(self.key, other.key) + return v diff --git a/dns/rdtypes/ANY/HIP.py b/dns/rdtypes/ANY/HIP.py index 2618ab10..0fe724f1 100644 --- a/dns/rdtypes/ANY/HIP.py +++ b/dns/rdtypes/ANY/HIP.py @@ -27,11 +27,11 @@ class HIP(dns.rdata.Rdata): """HIP record @ivar hit: the host identity tag - @type hit: string + @type hit: bytes @ivar algorithm: the public key cryptographic algorithm @type algorithm: int @ivar key: the public key - @type key: string + @type key: bytes @ivar servers: the rendezvous servers @type servers: list of dns.name.Name objects @see: RFC 5205""" @@ -88,10 +88,10 @@ class HIP(dns.rdata.Rdata): wire[current : current + 4]) current += 4 rdlen -= 4 - hit = wire[current : current + lh] + hit = wire[current : current + lh].unwrap() current += lh rdlen -= lh - key = wire[current : current + lk] + key = wire[current : current + lk].unwrap() current += lk rdlen -= lk servers = [] diff --git a/dns/rdtypes/ANY/ISDN.py b/dns/rdtypes/ANY/ISDN.py index 03235057..09ef415d 100644 --- a/dns/rdtypes/ANY/ISDN.py +++ b/dns/rdtypes/ANY/ISDN.py @@ -22,9 +22,9 @@ class ISDN(dns.rdata.Rdata): """ISDN record @ivar address: the ISDN address - @type address: string + @type address: bytes @ivar subaddress: the ISDN subaddress (or '' if not present) - @type subaddress: string + @type subaddress: bytes @see: RFC 1183""" __slots__ = ['address', 'subaddress'] @@ -72,7 +72,7 @@ class ISDN(dns.rdata.Rdata): rdlen -= 1 if l > rdlen: raise dns.exception.FormError - address = wire[current : current + l] + address = wire[current : current + l].unwrap() current += l rdlen -= l if rdlen > 0: @@ -81,7 +81,7 @@ class ISDN(dns.rdata.Rdata): rdlen -= 1 if l != rdlen: raise dns.exception.FormError - subaddress = wire[current : current + l] + subaddress = wire[current : current + l].unwrap() else: subaddress = b'' return cls(rdclass, rdtype, address, subaddress) diff --git a/dns/rdtypes/ANY/KEY.py b/dns/rdtypes/ANY/KEY.py deleted file mode 100644 index c8581edb..00000000 --- a/dns/rdtypes/ANY/KEY.py +++ /dev/null @@ -1,20 +0,0 @@ -# Copyright (C) 2003-2007, 2009, 2010 Nominum, Inc. -# -# Permission to use, copy, modify, and distribute this software and its -# documentation for any purpose with or without fee is hereby granted, -# provided that the above copyright notice and this permission notice -# appear in all copies. -# -# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES -# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF -# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR -# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES -# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN -# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT -# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -import dns.rdtypes.keybase - -class KEY(dns.rdtypes.keybase.KEYBase): - """KEY record""" - pass diff --git a/dns/rdtypes/ANY/NSEC.py b/dns/rdtypes/ANY/NSEC.py index 0a373d15..9d572aca 100644 --- a/dns/rdtypes/ANY/NSEC.py +++ b/dns/rdtypes/ANY/NSEC.py @@ -27,7 +27,7 @@ class NSEC(dns.rdata.Rdata): @ivar next: the next name @type next: dns.name.Name object @ivar windows: the windowed bitmap list - @type windows: list of (window number, string) tuples""" + @type windows: list of (window number, bytes) tuples""" __slots__ = ['next', 'windows'] @@ -112,7 +112,7 @@ class NSEC(dns.rdata.Rdata): rdlen -= 2 if rdlen < octets: raise dns.exception.FormError("bad NSEC bitmap length") - bitmap = wire[current : current + octets] + bitmap = wire[current : current + octets].unwrap() current += octets rdlen -= octets windows.append((window, bitmap)) @@ -126,17 +126,4 @@ class NSEC(dns.rdata.Rdata): self.next = self.next.choose_relativity(origin, relativize) def _cmp(self, other): - v = dns.util.cmp(self.next, other.next) - if v == 0: - b1 = io.BytesIO() - for (window, bitmap) in self.windows: - dns.util.write_uint8(b1, window) - dns.util.write_uint8(b1, len(bitmap)) - b1.write(bitmap) - b2 = io.BytesIO() - for (window, bitmap) in other.windows: - dns.util.write_uint8(b2, window) - dns.util.write_uint8(b2, len(bitmap)) - b2.write(bitmap) - v = dns.util.cmp(b1.getvalue(), b2.getvalue()) - return v + return self._wire_cmp(other) diff --git a/dns/rdtypes/ANY/NSEC3.py b/dns/rdtypes/ANY/NSEC3.py index c00f8cc6..9f975a12 100644 --- a/dns/rdtypes/ANY/NSEC3.py +++ b/dns/rdtypes/ANY/NSEC3.py @@ -44,11 +44,11 @@ class NSEC3(dns.rdata.Rdata): @ivar iterations: the number of iterations @type iterations: int @ivar salt: the salt - @type salt: string + @type salt: bytes @ivar next: the next name hash - @type next: string + @type next: bytes @ivar windows: the windowed bitmap list - @type windows: list of (window number, string) tuples""" + @type windows: list of (window number, bytes) tuples""" __slots__ = ['algorithm', 'flags', 'iterations', 'salt', 'next', 'windows'] @@ -148,13 +148,13 @@ class NSEC3(dns.rdata.Rdata): wire[current : current + 5]) current += 5 rdlen -= 5 - salt = wire[current : current + slen] + salt = wire[current : current + slen].unwrap() current += slen rdlen -= slen nlen = wire[current] current += 1 rdlen -= 1 - next = wire[current : current + nlen] + next = wire[current : current + nlen].unwrap() current += nlen rdlen -= nlen windows = [] @@ -169,7 +169,7 @@ class NSEC3(dns.rdata.Rdata): rdlen -= 2 if rdlen < octets: raise dns.exception.FormError("bad NSEC3 bitmap length") - bitmap = wire[current : current + octets] + bitmap = wire[current : current + octets].unwrap() current += octets rdlen -= octets windows.append((window, bitmap)) @@ -178,8 +178,4 @@ class NSEC3(dns.rdata.Rdata): from_wire = classmethod(from_wire) def _cmp(self, other): - b1 = io.BytesIO() - self.to_wire(b1) - b2 = io.BytesIO() - other.to_wire(b2) - return dns.util.cmp(b1.getvalue(), b2.getvalue()) + return self._wire_cmp(other) diff --git a/dns/rdtypes/ANY/NSEC3PARAM.py b/dns/rdtypes/ANY/NSEC3PARAM.py index 03bc1890..f2fd009a 100644 --- a/dns/rdtypes/ANY/NSEC3PARAM.py +++ b/dns/rdtypes/ANY/NSEC3PARAM.py @@ -31,7 +31,7 @@ class NSEC3PARAM(dns.rdata.Rdata): @ivar iterations: the number of iterations @type iterations: int @ivar salt: the salt - @type salt: string""" + @type salt: bytes""" __slots__ = ['algorithm', 'flags', 'iterations', 'salt'] @@ -73,7 +73,7 @@ class NSEC3PARAM(dns.rdata.Rdata): wire[current : current + 5]) current += 5 rdlen -= 5 - salt = wire[current : current + slen] + salt = wire[current : current + slen].unwrap() current += slen rdlen -= slen if rdlen != 0: @@ -83,8 +83,4 @@ class NSEC3PARAM(dns.rdata.Rdata): from_wire = classmethod(from_wire) def _cmp(self, other): - b1 = io.BytesIO() - self.to_wire(b1) - b2 = io.BytesIO() - other.to_wire(b2) - return dns.util.cmp(b1.getvalue(), b2.getvalue()) + return self._wire_cmp(other) diff --git a/dns/rdtypes/ANY/NXT.py b/dns/rdtypes/ANY/NXT.py deleted file mode 100644 index 9721cb60..00000000 --- a/dns/rdtypes/ANY/NXT.py +++ /dev/null @@ -1,97 +0,0 @@ -# Copyright (C) 2003-2007, 2009, 2010 Nominum, Inc. -# -# Permission to use, copy, modify, and distribute this software and its -# documentation for any purpose with or without fee is hereby granted, -# provided that the above copyright notice and this permission notice -# appear in all copies. -# -# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES -# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF -# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR -# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES -# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN -# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT -# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -import dns.exception -import dns.rdata -import dns.rdatatype -import dns.name -import dns.util - -class NXT(dns.rdata.Rdata): - """NXT record - - @ivar next: the next name - @type next: dns.name.Name object - @ivar bitmap: the type bitmap - @type bitmap: string - @see: RFC 2535""" - - __slots__ = ['next', 'bitmap'] - - def __init__(self, rdclass, rdtype, next, bitmap): - super(NXT, self).__init__(rdclass, rdtype) - self.next = next - self.bitmap = bitmap - - def to_text(self, origin=None, relativize=True, **kw): - next = self.next.choose_relativity(origin, relativize) - bits = [] - for i in range(0, len(self.bitmap)): - byte = self.bitmap[i] - for j in range(0, 8): - if byte & (0x80 >> j): - bits.append(dns.rdatatype.to_text(i * 8 + j)) - text = ' '.join(bits) - return '%s %s' % (next, text) - - def from_text(cls, rdclass, rdtype, tok, origin = None, relativize = True): - next = tok.get_name() - next = next.choose_relativity(origin, relativize) - bitmap = bytearray(32) - while 1: - token = tok.get().unescape() - if token.is_eol_or_eof(): - break - if token.value.isdigit(): - nrdtype = int(token.value) - else: - nrdtype = dns.rdatatype.from_text(token.value) - if nrdtype == 0: - raise dns.exception.SyntaxError("NXT with bit 0") - if nrdtype > 127: - raise dns.exception.SyntaxError("NXT with bit > 127") - i = nrdtype // 8 - bitmap[i] = bitmap[i] | (0x80 >> (nrdtype % 8)) - bitmap = dns.rdata._truncate_bitmap(bitmap) - return cls(rdclass, rdtype, next, bitmap) - - from_text = classmethod(from_text) - - def to_wire(self, file, compress = None, origin = None): - self.next.to_wire(file, None, origin) - file.write(self.bitmap) - - def to_digestable(self, origin = None): - return self.next.to_digestable(origin) + self.bitmap - - def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None): - (next, cused) = dns.name.from_wire(wire[: current + rdlen], current) - current += cused - rdlen -= cused - bitmap = wire[current : current + rdlen] - if not origin is None: - next = next.relativize(origin) - return cls(rdclass, rdtype, next, bitmap) - - from_wire = classmethod(from_wire) - - def choose_relativity(self, origin = None, relativize = True): - self.next = self.next.choose_relativity(origin, relativize) - - def _cmp(self, other): - v = dns.util.cmp(self.next, other.next) - if v == 0: - v = dns.util.cmp(self.bitmap, other.bitmap) - return v diff --git a/dns/rdtypes/ANY/RRSIG.py b/dns/rdtypes/ANY/RRSIG.py index 0e4816f6..6f872553 100644 --- a/dns/rdtypes/ANY/RRSIG.py +++ b/dns/rdtypes/ANY/RRSIG.py @@ -13,8 +13,156 @@ # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -import dns.rdtypes.sigbase +import base64 +import calendar +import struct +import time -class RRSIG(dns.rdtypes.sigbase.SIGBase): - """RRSIG record""" +import dns.dnssec +import dns.exception +import dns.rdata +import dns.rdatatype +import dns.util + +class BadSigTime(dns.exception.DNSException): + """Raised when a SIG or RRSIG RR's time cannot be parsed.""" pass + +def sigtime_to_posixtime(what): + if len(what) != 14: + raise BadSigTime + year = int(what[0:4]) + month = int(what[4:6]) + day = int(what[6:8]) + hour = int(what[8:10]) + minute = int(what[10:12]) + second = int(what[12:14]) + return calendar.timegm((year, month, day, hour, minute, second, + 0, 0, 0)) + +def posixtime_to_sigtime(what): + return time.strftime('%Y%m%d%H%M%S', time.gmtime(what)) + +class RRSIG(dns.rdata.Rdata): + """RRSIG record + + @ivar type_covered: the rdata type this signature covers + @type type_covered: int + @ivar algorithm: the algorithm used for the sig + @type algorithm: int + @ivar labels: number of labels + @type labels: int + @ivar original_ttl: the original TTL + @type original_ttl: long + @ivar expiration: signature expiration time + @type expiration: long + @ivar inception: signature inception time + @type inception: long + @ivar key_tag: the key tag + @type key_tag: int + @ivar signer: the signer + @type signer: dns.name.Name object + @ivar signature: the signature + @type signature: string""" + + __slots__ = ['type_covered', 'algorithm', 'labels', 'original_ttl', + 'expiration', 'inception', 'key_tag', 'signer', + 'signature'] + + def __init__(self, rdclass, rdtype, type_covered, algorithm, labels, + original_ttl, expiration, inception, key_tag, signer, + signature): + super(RRSIG, self).__init__(rdclass, rdtype) + self.type_covered = type_covered + self.algorithm = algorithm + self.labels = labels + self.original_ttl = original_ttl + self.expiration = expiration + self.inception = inception + self.key_tag = key_tag + self.signer = signer + self.signature = signature + + def covers(self): + return self.type_covered + + def to_text(self, origin=None, relativize=True, **kw): + return '%s %d %d %d %s %s %d %s %s' % ( + dns.rdatatype.to_text(self.type_covered), + self.algorithm, + self.labels, + self.original_ttl, + posixtime_to_sigtime(self.expiration), + posixtime_to_sigtime(self.inception), + self.key_tag, + self.signer, + dns.rdata._base64ify(self.signature) + ) + + @classmethod + def from_text(cls, rdclass, rdtype, tok, origin = None, relativize = True): + type_covered = dns.rdatatype.from_text(tok.get_string()) + algorithm = dns.dnssec.algorithm_from_text(tok.get_string()) + labels = tok.get_int() + original_ttl = tok.get_ttl() + expiration = sigtime_to_posixtime(tok.get_string()) + inception = sigtime_to_posixtime(tok.get_string()) + key_tag = tok.get_int() + signer = tok.get_name() + signer = signer.choose_relativity(origin, relativize) + chunks = [] + while 1: + t = tok.get().unescape() + if t.is_eol_or_eof(): + break + if not t.is_identifier(): + raise dns.exception.SyntaxError + chunks.append(t.value) + b64 = ''.join(chunks) + signature = base64.b64decode(b64.encode('ascii')) + return cls(rdclass, rdtype, type_covered, algorithm, labels, + original_ttl, expiration, inception, key_tag, signer, + signature) + + def to_wire(self, file, compress = None, origin = None): + header = struct.pack('!HBBIIIH', self.type_covered, + self.algorithm, self.labels, + self.original_ttl, self.expiration, + self.inception, self.key_tag) + file.write(header) + self.signer.to_wire(file, None, origin) + file.write(self.signature) + + @classmethod + def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None): + header = struct.unpack('!HBBIIIH', wire[current : current + 18]) + current += 18 + rdlen -= 18 + (signer, cused) = dns.name.from_wire(wire[: current + rdlen], current) + current += cused + rdlen -= cused + if not origin is None: + signer = signer.relativize(origin) + signature = wire[current : current + rdlen].unwrap() + return cls(rdclass, rdtype, header[0], header[1], header[2], + header[3], header[4], header[5], header[6], signer, + signature) + + def choose_relativity(self, origin = None, relativize = True): + self.signer = self.signer.choose_relativity(origin, relativize) + + def _cmp(self, other): + hs = struct.pack('!HBBIIIH', self.type_covered, + self.algorithm, self.labels, + self.original_ttl, self.expiration, + self.inception, self.key_tag) + ho = struct.pack('!HBBIIIH', other.type_covered, + other.algorithm, other.labels, + other.original_ttl, other.expiration, + other.inception, other.key_tag) + v = dns.util.cmp(hs, ho) + if v == 0: + v = dns.util.cmp(self.signer, other.signer) + if v == 0: + v = dns.util.cmp(self.signature, other.signature) + return v diff --git a/dns/rdtypes/ANY/SIG.py b/dns/rdtypes/ANY/SIG.py deleted file mode 100644 index 501e29cc..00000000 --- a/dns/rdtypes/ANY/SIG.py +++ /dev/null @@ -1,26 +0,0 @@ -# Copyright (C) 2003-2007, 2009, 2010 Nominum, Inc. -# -# Permission to use, copy, modify, and distribute this software and its -# documentation for any purpose with or without fee is hereby granted, -# provided that the above copyright notice and this permission notice -# appear in all copies. -# -# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES -# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF -# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR -# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES -# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN -# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT -# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -import dns.rdtypes.sigbase - -class SIG(dns.rdtypes.sigbase.SIGBase): - """SIG record""" - def to_digestable(self, origin = None): - return struct.pack('!HBBIIIH', self.type_covered, - self.algorithm, self.labels, - self.original_ttl, self.expiration, - self.inception, self.key_tag) + \ - self.signer.to_digestable(origin) + \ - self.signature diff --git a/dns/rdtypes/ANY/SSHFP.py b/dns/rdtypes/ANY/SSHFP.py index 6505b2c9..b3f4d6cb 100644 --- a/dns/rdtypes/ANY/SSHFP.py +++ b/dns/rdtypes/ANY/SSHFP.py @@ -27,7 +27,7 @@ class SSHFP(dns.rdata.Rdata): @ivar fp_type: the digest type @type fp_type: int @ivar fingerprint: the fingerprint - @type fingerprint: string + @type fingerprint: bytes @see: draft-ietf-secsh-dns-05.txt""" __slots__ = ['algorithm', 'fp_type', 'fingerprint'] @@ -63,7 +63,7 @@ class SSHFP(dns.rdata.Rdata): header = struct.unpack("!BB", wire[current : current + 2]) current += 2 rdlen -= 2 - fingerprint = wire[current : current + rdlen] + fingerprint = wire[current : current + rdlen].unwrap() return cls(rdclass, rdtype, header[0], header[1], fingerprint) from_wire = classmethod(from_wire) diff --git a/dns/rdtypes/ANY/__init__.py b/dns/rdtypes/ANY/__init__.py index 0815dd54..76815c46 100644 --- a/dns/rdtypes/ANY/__init__.py +++ b/dns/rdtypes/ANY/__init__.py @@ -27,19 +27,16 @@ __all__ = [ 'HINFO', 'HIP', 'ISDN', - 'KEY', 'LOC', 'MX', 'NS', 'NSEC', 'NSEC3', 'NSEC3PARAM', - 'NXT', 'PTR', 'RP', 'RRSIG', 'RT', - 'SIG', 'SOA', 'SPF', 'SSHFP', diff --git a/dns/rdtypes/IN/APL.py b/dns/rdtypes/IN/APL.py index 5bb7b28e..46ba6bfd 100644 --- a/dns/rdtypes/IN/APL.py +++ b/dns/rdtypes/IN/APL.py @@ -132,7 +132,7 @@ class APL(dns.rdata.Rdata): rdlen -= 4 if rdlen < afdlen: raise dns.exception.FormError - address = wire[current : current + afdlen] + address = wire[current : current + afdlen].unwrap() l = len(address) if header[0] == 1: if l < 4: diff --git a/dns/rdtypes/IN/DHCID.py b/dns/rdtypes/IN/DHCID.py index ef4654ad..7ddf213e 100644 --- a/dns/rdtypes/IN/DHCID.py +++ b/dns/rdtypes/IN/DHCID.py @@ -23,7 +23,7 @@ class DHCID(dns.rdata.Rdata): @ivar data: the data (the content of the RR is opaque as far as the DNS is concerned) - @type data: string + @type data: bytes @see: RFC 4701""" __slots__ = ['data'] @@ -54,7 +54,7 @@ class DHCID(dns.rdata.Rdata): file.write(self.data) def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None): - data = wire[current : current + rdlen] + data = wire[current : current + rdlen].unwrap() return cls(rdclass, rdtype, data) from_wire = classmethod(from_wire) diff --git a/dns/rdtypes/IN/IPSECKEY.py b/dns/rdtypes/IN/IPSECKEY.py index 3a7810a3..0ef053cd 100644 --- a/dns/rdtypes/IN/IPSECKEY.py +++ b/dns/rdtypes/IN/IPSECKEY.py @@ -34,7 +34,7 @@ class IPSECKEY(dns.rdata.Rdata): @ivar gateway: the public key @type gateway: None, IPv4 address, IPV6 address, or domain name @ivar key: the public key - @type key: string + @type key: bytes @see: RFC 4025""" __slots__ = ['precedence', 'gateway_type', 'algorithm', 'gateway', 'key'] @@ -142,7 +142,7 @@ class IPSECKEY(dns.rdata.Rdata): rdlen -= cused else: raise dns.exception.FormError('invalid IPSECKEY gateway type') - key = wire[current : current + rdlen] + key = wire[current : current + rdlen].unwrap() return cls(rdclass, rdtype, header[0], gateway_type, header[2], gateway, key) diff --git a/dns/rdtypes/IN/NSAP.py b/dns/rdtypes/IN/NSAP.py index 1d66114c..5c6a7b6b 100644 --- a/dns/rdtypes/IN/NSAP.py +++ b/dns/rdtypes/IN/NSAP.py @@ -21,8 +21,8 @@ import dns.util class NSAP(dns.rdata.Rdata): """NSAP record. - @ivar address: a NASP - @type address: string + @ivar address: a NSAP + @type address: bytes @see: RFC 1706""" __slots__ = ['address'] @@ -51,7 +51,7 @@ class NSAP(dns.rdata.Rdata): file.write(self.address) def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None): - address = wire[current : current + rdlen] + address = wire[current : current + rdlen].unwrap() return cls(rdclass, rdtype, address) from_wire = classmethod(from_wire) diff --git a/dns/rdtypes/IN/WKS.py b/dns/rdtypes/IN/WKS.py index f0b169e0..44e82069 100644 --- a/dns/rdtypes/IN/WKS.py +++ b/dns/rdtypes/IN/WKS.py @@ -31,7 +31,7 @@ class WKS(dns.rdata.Rdata): @ivar protocol: the protocol @type protocol: int @ivar bitmap: the bitmap - @type bitmap: string + @type bitmap: bytes @see: RFC 1035""" __slots__ = ['address', 'protocol', 'bitmap'] @@ -92,7 +92,7 @@ class WKS(dns.rdata.Rdata): protocol, = struct.unpack('!B', wire[current + 4 : current + 5]) current += 5 rdlen -= 5 - bitmap = wire[current : current + rdlen] + bitmap = wire[current : current + rdlen].unwrap() return cls(rdclass, rdtype, address, protocol, bitmap) from_wire = classmethod(from_wire) diff --git a/dns/rdtypes/__init__.py b/dns/rdtypes/__init__.py index 13282be7..fcc056f7 100644 --- a/dns/rdtypes/__init__.py +++ b/dns/rdtypes/__init__.py @@ -20,6 +20,4 @@ __all__ = [ 'IN', 'mxbase', 'nsbase', - 'sigbase', - 'keybase', ] diff --git a/dns/rdtypes/dsbase.py b/dns/rdtypes/dsbase.py index 139c249a..eee2ddfe 100644 --- a/dns/rdtypes/dsbase.py +++ b/dns/rdtypes/dsbase.py @@ -29,7 +29,7 @@ class DSBase(dns.rdata.Rdata): @ivar digest_type: the digest type @type digest_type: int @ivar digest: the digest - @type digest: int + @type digest: bytes @see: draft-ietf-dnsext-delegation-signer-14.txt""" __slots__ = ['key_tag', 'algorithm', 'digest_type', 'digest'] @@ -76,7 +76,7 @@ class DSBase(dns.rdata.Rdata): header = struct.unpack("!HBB", wire[current : current + 4]) current += 4 rdlen -= 4 - digest = wire[current : current + rdlen] + digest = wire[current : current + rdlen].unwrap() return cls(rdclass, rdtype, header[0], header[1], header[2], digest) def _cmp(self, other): diff --git a/dns/rdtypes/keybase.py b/dns/rdtypes/keybase.py deleted file mode 100644 index 3b186902..00000000 --- a/dns/rdtypes/keybase.py +++ /dev/null @@ -1,149 +0,0 @@ -# Copyright (C) 2004-2007, 2009, 2010 Nominum, Inc. -# -# Permission to use, copy, modify, and distribute this software and its -# documentation for any purpose with or without fee is hereby granted, -# provided that the above copyright notice and this permission notice -# appear in all copies. -# -# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES -# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF -# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR -# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES -# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN -# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT -# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -import base64 -import struct - -import dns.exception -import dns.dnssec -import dns.rdata -import dns.util - -_flags_from_text = { - 'NOCONF': (0x4000, 0xC000), - 'NOAUTH': (0x8000, 0xC000), - 'NOKEY': (0xC000, 0xC000), - 'FLAG2': (0x2000, 0x2000), - 'EXTEND': (0x1000, 0x1000), - 'FLAG4': (0x0800, 0x0800), - 'FLAG5': (0x0400, 0x0400), - 'USER': (0x0000, 0x0300), - 'ZONE': (0x0100, 0x0300), - 'HOST': (0x0200, 0x0300), - 'NTYP3': (0x0300, 0x0300), - 'FLAG8': (0x0080, 0x0080), - 'FLAG9': (0x0040, 0x0040), - 'FLAG10': (0x0020, 0x0020), - 'FLAG11': (0x0010, 0x0010), - 'SIG0': (0x0000, 0x000f), - 'SIG1': (0x0001, 0x000f), - 'SIG2': (0x0002, 0x000f), - 'SIG3': (0x0003, 0x000f), - 'SIG4': (0x0004, 0x000f), - 'SIG5': (0x0005, 0x000f), - 'SIG6': (0x0006, 0x000f), - 'SIG7': (0x0007, 0x000f), - 'SIG8': (0x0008, 0x000f), - 'SIG9': (0x0009, 0x000f), - 'SIG10': (0x000a, 0x000f), - 'SIG11': (0x000b, 0x000f), - 'SIG12': (0x000c, 0x000f), - 'SIG13': (0x000d, 0x000f), - 'SIG14': (0x000e, 0x000f), - 'SIG15': (0x000f, 0x000f), - } - -_protocol_from_text = { - 'NONE' : 0, - 'TLS' : 1, - 'EMAIL' : 2, - 'DNSSEC' : 3, - 'IPSEC' : 4, - 'ALL' : 255, - } - -class KEYBase(dns.rdata.Rdata): - """KEY-like record base - - @ivar flags: the key flags - @type flags: int - @ivar protocol: the protocol for which this key may be used - @type protocol: int - @ivar algorithm: the algorithm used for the key - @type algorithm: int - @ivar key: the public key - @type key: string""" - - __slots__ = ['flags', 'protocol', 'algorithm', 'key'] - - def __init__(self, rdclass, rdtype, flags, protocol, algorithm, key): - super(KEYBase, self).__init__(rdclass, rdtype) - self.flags = flags - self.protocol = protocol - self.algorithm = algorithm - self.key = key - - def to_text(self, origin=None, relativize=True, **kw): - return '%d %d %d %s' % (self.flags, self.protocol, self.algorithm, - dns.rdata._base64ify(self.key)) - - @classmethod - def from_text(cls, rdclass, rdtype, tok, origin = None, relativize = True): - flags = tok.get_string() - if flags.isdigit(): - flags = int(flags) - else: - flag_names = flags.split('|') - flags = 0 - for flag in flag_names: - v = _flags_from_text.get(flag) - if v is None: - raise dns.exception.SyntaxError('unknown flag %s' % flag) - flags &= ~v[1] - flags |= v[0] - protocol = tok.get_string() - if protocol.isdigit(): - protocol = int(protocol) - else: - protocol = _protocol_from_text.get(protocol) - if protocol is None: - raise dns.exception.SyntaxError('unknown protocol %s' % protocol) - - algorithm = dns.dnssec.algorithm_from_text(tok.get_string()) - chunks = [] - while 1: - t = tok.get().unescape() - if t.is_eol_or_eof(): - break - if not t.is_identifier(): - raise dns.exception.SyntaxError - chunks.append(t.value) - b64 = ''.join(chunks) - key = base64.b64decode(b64.encode('ascii')) - return cls(rdclass, rdtype, flags, protocol, algorithm, key) - - def to_wire(self, file, compress = None, origin = None): - header = struct.pack("!HBB", self.flags, self.protocol, self.algorithm) - file.write(header) - file.write(self.key) - - @classmethod - def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None): - if rdlen < 4: - raise dns.exception.FormError - header = struct.unpack('!HBB', wire[current : current + 4]) - current += 4 - rdlen -= 4 - key = wire[current : current + rdlen] - return cls(rdclass, rdtype, header[0], header[1], header[2], - key) - - def _cmp(self, other): - hs = struct.pack("!HBB", self.flags, self.protocol, self.algorithm) - ho = struct.pack("!HBB", other.flags, other.protocol, other.algorithm) - v = dns.util.cmp(hs, ho) - if v == 0: - v = dns.util.cmp(self.key, other.key) - return v diff --git a/dns/rdtypes/sigbase.py b/dns/rdtypes/sigbase.py deleted file mode 100644 index 1df1f31d..00000000 --- a/dns/rdtypes/sigbase.py +++ /dev/null @@ -1,168 +0,0 @@ -# Copyright (C) 2004-2007, 2009, 2010 Nominum, Inc. -# -# Permission to use, copy, modify, and distribute this software and its -# documentation for any purpose with or without fee is hereby granted, -# provided that the above copyright notice and this permission notice -# appear in all copies. -# -# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES -# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF -# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR -# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES -# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN -# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT -# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -import base64 -import calendar -import struct -import time - -import dns.dnssec -import dns.exception -import dns.rdata -import dns.rdatatype -import dns.util - -class BadSigTime(dns.exception.DNSException): - """Raised when a SIG or RRSIG RR's time cannot be parsed.""" - pass - -def sigtime_to_posixtime(what): - if len(what) != 14: - raise BadSigTime - year = int(what[0:4]) - month = int(what[4:6]) - day = int(what[6:8]) - hour = int(what[8:10]) - minute = int(what[10:12]) - second = int(what[12:14]) - return calendar.timegm((year, month, day, hour, minute, second, - 0, 0, 0)) - -def posixtime_to_sigtime(what): - return time.strftime('%Y%m%d%H%M%S', time.gmtime(what)) - -class SIGBase(dns.rdata.Rdata): - """SIG-like record base - - @ivar type_covered: the rdata type this signature covers - @type type_covered: int - @ivar algorithm: the algorithm used for the sig - @type algorithm: int - @ivar labels: number of labels - @type labels: int - @ivar original_ttl: the original TTL - @type original_ttl: long - @ivar expiration: signature expiration time - @type expiration: long - @ivar inception: signature inception time - @type inception: long - @ivar key_tag: the key tag - @type key_tag: int - @ivar signer: the signer - @type signer: dns.name.Name object - @ivar signature: the signature - @type signature: string""" - - __slots__ = ['type_covered', 'algorithm', 'labels', 'original_ttl', - 'expiration', 'inception', 'key_tag', 'signer', - 'signature'] - - def __init__(self, rdclass, rdtype, type_covered, algorithm, labels, - original_ttl, expiration, inception, key_tag, signer, - signature): - super(SIGBase, self).__init__(rdclass, rdtype) - self.type_covered = type_covered - self.algorithm = algorithm - self.labels = labels - self.original_ttl = original_ttl - self.expiration = expiration - self.inception = inception - self.key_tag = key_tag - self.signer = signer - self.signature = signature - - def covers(self): - return self.type_covered - - def to_text(self, origin=None, relativize=True, **kw): - return '%s %d %d %d %s %s %d %s %s' % ( - dns.rdatatype.to_text(self.type_covered), - self.algorithm, - self.labels, - self.original_ttl, - posixtime_to_sigtime(self.expiration), - posixtime_to_sigtime(self.inception), - self.key_tag, - self.signer, - dns.rdata._base64ify(self.signature) - ) - - @classmethod - def from_text(cls, rdclass, rdtype, tok, origin = None, relativize = True): - type_covered = dns.rdatatype.from_text(tok.get_string()) - algorithm = dns.dnssec.algorithm_from_text(tok.get_string()) - labels = tok.get_int() - original_ttl = tok.get_ttl() - expiration = sigtime_to_posixtime(tok.get_string()) - inception = sigtime_to_posixtime(tok.get_string()) - key_tag = tok.get_int() - signer = tok.get_name() - signer = signer.choose_relativity(origin, relativize) - chunks = [] - while 1: - t = tok.get().unescape() - if t.is_eol_or_eof(): - break - if not t.is_identifier(): - raise dns.exception.SyntaxError - chunks.append(t.value) - b64 = ''.join(chunks) - signature = base64.b64decode(b64.encode('ascii')) - return cls(rdclass, rdtype, type_covered, algorithm, labels, - original_ttl, expiration, inception, key_tag, signer, - signature) - - def to_wire(self, file, compress = None, origin = None): - header = struct.pack('!HBBIIIH', self.type_covered, - self.algorithm, self.labels, - self.original_ttl, self.expiration, - self.inception, self.key_tag) - file.write(header) - self.signer.to_wire(file, None, origin) - file.write(self.signature) - - @classmethod - def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None): - header = struct.unpack('!HBBIIIH', wire[current : current + 18]) - current += 18 - rdlen -= 18 - (signer, cused) = dns.name.from_wire(wire[: current + rdlen], current) - current += cused - rdlen -= cused - if not origin is None: - signer = signer.relativize(origin) - signature = wire[current : current + rdlen] - return cls(rdclass, rdtype, header[0], header[1], header[2], - header[3], header[4], header[5], header[6], signer, - signature) - - def choose_relativity(self, origin = None, relativize = True): - self.signer = self.signer.choose_relativity(origin, relativize) - - def _cmp(self, other): - hs = struct.pack('!HBBIIIH', self.type_covered, - self.algorithm, self.labels, - self.original_ttl, self.expiration, - self.inception, self.key_tag) - ho = struct.pack('!HBBIIIH', other.type_covered, - other.algorithm, other.labels, - other.original_ttl, other.expiration, - other.inception, other.key_tag) - v = dns.util.cmp(hs, ho) - if v == 0: - v = dns.util.cmp(self.signer, other.signer) - if v == 0: - v = dns.util.cmp(self.signature, other.signature) - return v diff --git a/dns/resolver.py b/dns/resolver.py index db8a1b5d..55a7b861 100644 --- a/dns/resolver.py +++ b/dns/resolver.py @@ -92,8 +92,11 @@ class Answer(object): @type rrset: dns.rrset.RRset object @ivar expiration: The time when the answer expires @type expiration: float (seconds since the epoch) + @ivar canonical_name: The canonical name of the query name + @type canonical_name: dns.name.Name object """ - def __init__(self, qname, rdtype, rdclass, response): + def __init__(self, qname, rdtype, rdclass, response, + raise_on_no_answer=True): self.qname = qname self.rdtype = rdtype self.rdclass = rdclass @@ -121,11 +124,31 @@ class Answer(object): break continue except KeyError: - raise NoAnswer - raise NoAnswer - if rrset is None: + if raise_on_no_answer: + raise NoAnswer + if raise_on_no_answer: + raise NoAnswer + if rrset is None and raise_on_no_answer: raise NoAnswer + self.canonical_name = qname self.rrset = rrset + if rrset is None: + while 1: + # Look for a SOA RR whose owner name is a superdomain + # of qname. + try: + srrset = response.find_rrset(response.authority, qname, + rdclass, dns.rdatatype.SOA) + if min_ttl == -1 or srrset.ttl < min_ttl: + min_ttl = srrset.ttl + if srrset[0].minimum < min_ttl: + min_ttl = srrset[0].minimum + break + except KeyError: + try: + qname = qname.parent() + except dns.name.NoParent: + break self.expiration = time.time() + min_ttl def __getattr__(self, attr): @@ -540,7 +563,7 @@ class Resolver(object): return min(self.lifetime - duration, self.timeout) def query(self, qname, rdtype=dns.rdatatype.A, rdclass=dns.rdataclass.IN, - tcp=False, source=None): + tcp=False, source=None, raise_on_no_answer=True): """Query nameservers to find the answer to the question. The I{qname}, I{rdtype}, and I{rdclass} parameters may be objects @@ -558,10 +581,14 @@ class Resolver(object): @type tcp: bool @param source: bind to this IP address (defaults to machine default IP). @type source: IP address in dotted quad notation + @param raise_on_no_answer: raise NoAnswer if there's no answer + (defaults is True). + @type raise_on_no_answer: bool @rtype: dns.resolver.Answer instance @raises Timeout: no answers could be found in the specified lifetime @raises NXDOMAIN: the query name does not exist - @raises NoAnswer: the response did not contain an answer + @raises NoAnswer: the response did not contain an answer and + raise_on_no_answer is True. @raises NoNameservers: no non-broken nameservers are available to answer the question.""" @@ -672,7 +699,8 @@ class Resolver(object): break if all_nxdomain: raise NXDOMAIN - answer = Answer(qname, rdtype, rdclass, response) + answer = Answer(qname, rdtype, rdclass, response, + raise_on_no_answer) if self.cache: self.cache.put((qname, rdtype, rdclass), answer) return answer @@ -725,14 +753,15 @@ def get_default_resolver(): return default_resolver def query(qname, rdtype=dns.rdatatype.A, rdclass=dns.rdataclass.IN, - tcp=False, source=None): + tcp=False, source=None, raise_on_no_answer=True): """Query nameservers to find the answer to the question. This is a convenience function that uses the default resolver object to make the query. @see: L{dns.resolver.Resolver.query} for more information on the parameters.""" - return get_default_resolver().query(qname, rdtype, rdclass, tcp, source) + return get_default_resolver().query(qname, rdtype, rdclass, tcp, source, + raise_on_no_answer) def zone_for_name(name, rdclass=dns.rdataclass.IN, tcp=False, resolver=None): """Find the name of the zone which contains the specified name. diff --git a/dns/version.py b/dns/version.py index 46799a77..4cc9e461 100644 --- a/dns/version.py +++ b/dns/version.py @@ -17,7 +17,7 @@ MAJOR = 1 MINOR = 9 -MICRO = 3 +MICRO = 5 RELEASELEVEL = 0x0f SERIAL = 0 diff --git a/dns/wiredata.py b/dns/wiredata.py new file mode 100644 index 00000000..0870a66d --- /dev/null +++ b/dns/wiredata.py @@ -0,0 +1,64 @@ +# Copyright (C) 2011 Nominum, Inc. +# +# Permission to use, copy, modify, and distribute this software and its +# documentation for any purpose with or without fee is hereby granted, +# provided that the above copyright notice and this permission notice +# appear in all copies. +# +# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES +# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR +# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +"""DNS Wire Data Helper""" + +import sys + +import dns.exception + +class WireData(bytes): + # WireData is a bytes with stricter slicing + def __getitem__(self, key): + try: + if isinstance(key, slice): + start = key.start + if start is None: + start = 0 + elif start < 0: + start += len(self) + stop = key.stop + if stop is None: + stop = len(self) + elif stop < 0: + stop += len(self) + if start < 0 or stop < 0: + raise dns.exception.FormError + # If it's not an empty slice, access left and right bounds + # to make sure they're valid + if start != stop: + super(WireData, self).__getitem__(start) + super(WireData, self).__getitem__(stop - 1) + return WireData(super(WireData, self).__getitem__(key)) + else: + return super(WireData, self).__getitem__(key) + except IndexError: + raise dns.exception.FormError + def __iter__(self): + i = 0 + while 1: + try: + yield self[i] + i += 1 + except dns.exception.FormError: + raise StopIteration + def unwrap(self): + return bytes(self) + +def maybe_wrap(wire): + if not isinstance(wire, WireData): + return WireData(wire) + else: + return wire diff --git a/setup.py b/setup.py index f84711f7..9d7cbad8 100755 --- a/setup.py +++ b/setup.py @@ -18,7 +18,7 @@ import sys from distutils.core import setup -version = '1.9.3' +version = '1.9.5' kwargs = { 'name' : 'dnspython', @@ -38,13 +38,10 @@ direct manipulation of DNS zones, messages, names, and records.""", 'license' : 'BSD-like', 'url' : 'http://www.dnspython.org', 'packages' : ['dns', 'dns.rdtypes', 'dns.rdtypes.IN', 'dns.rdtypes.ANY'], - } - -if sys.hexversion >= 0x02020300: - kwargs['download_url'] = \ + 'download_url' : \ 'http://www.dnspython.org/kits/%s/dnspython-%s.tar.gz' % (version, - version) - kwargs['classifiers'] = [ + version), + 'classifiers' : [ "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "Intended Audience :: System Administrators", @@ -54,10 +51,9 @@ if sys.hexversion >= 0x02020300: "Programming Language :: Python", "Topic :: Internet :: Name Service (DNS)", "Topic :: Software Development :: Libraries :: Python Modules", - ] - -if sys.hexversion >= 0x02050000: - kwargs['requires'] = [] - kwargs['provides'] = ['dns'] + ], + 'requires' : [], + 'provides' : ['dns'], + } setup(**kwargs) diff --git a/tests/Makefile b/tests/Makefile index e375d915..1f09b18b 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -15,7 +15,7 @@ # $Id: Makefile,v 1.5 2004/03/19 00:17:27 halley Exp $ -PYTHON=python3.1 +PYTHON=python3.2 check: test diff --git a/tests/bugs.py b/tests/bugs.py index 0896e3f0..832bd4c0 100644 --- a/tests/bugs.py +++ b/tests/bugs.py @@ -25,20 +25,20 @@ class BugsTestCase(unittest.TestCase): def test_float_LOC(self): rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.LOC, "30 30 0.000 N 100 30 0.000 W 10.00m 20m 2000m 20m") - self.failUnless(rdata.float_latitude == 30.5) - self.failUnless(rdata.float_longitude == -100.5) + self.assertTrue(rdata.float_latitude == 30.5) + self.assertTrue(rdata.float_longitude == -100.5) def test_SOA_BIND8_TTL(self): rdata1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, "a b 100 1s 1m 1h 1d") rdata2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA, "a b 100 1 60 3600 86400") - self.failUnless(rdata1 == rdata2) + self.assertTrue(rdata1 == rdata2) def test_TTL_bounds_check(self): def bad(): ttl = dns.ttl.from_text("2147483648") - self.failUnlessRaises(dns.ttl.BadTTL, bad) + self.assertRaises(dns.ttl.BadTTL, bad) if __name__ == '__main__': unittest.main() diff --git a/tests/dnssec.py b/tests/dnssec.py index 371a30c7..3ff88341 100644 --- a/tests/dnssec.py +++ b/tests/dnssec.py @@ -99,7 +99,7 @@ class DNSSECValidatorTestCase(unittest.TestCase): def bad(): 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): dns.dnssec.validate(rel_soa, rel_soa_rrsig, rel_keys, @@ -109,11 +109,11 @@ class DNSSECValidatorTestCase(unittest.TestCase): def bad(): 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 testMakeSHA256DS(self): ds = dns.dnssec.make_ds(abs_dnspython_org, sep_key, 'SHA256') - self.failUnless(ds == good_ds) + self.assertTrue(ds == good_ds) def testAbsoluteDSAGood(self): dns.dnssec.validate(abs_dsa_soa, abs_dsa_soa_rrsig, abs_dsa_keys, None, @@ -123,15 +123,15 @@ class DNSSECValidatorTestCase(unittest.TestCase): def bad(): 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) def testMakeExampleSHA1DS(self): ds = dns.dnssec.make_ds(abs_example, example_sep_key, 'SHA1') - self.failUnless(ds == example_ds_sha1) + self.assertTrue(ds == example_ds_sha1) def testMakeExampleSHA256DS(self): ds = dns.dnssec.make_ds(abs_example, example_sep_key, 'SHA256') - self.failUnless(ds == example_ds_sha256) + self.assertTrue(ds == example_ds_sha256) if __name__ == '__main__': import_ok = False diff --git a/tests/example b/tests/example index e8fed116..2f753a2f 100644 --- a/tests/example +++ b/tests/example @@ -101,16 +101,17 @@ isdn01 ISDN "isdn-address" isdn02 ISDN "isdn-address" "subaddress" isdn03 ISDN "isdn-address" isdn04 ISDN "isdn-address" "subaddress" -key01 KEY 512 255 1 ( - AQMFD5raczCJHViKtLYhWGz8hMY9UGRuniJDBzC7w0aR - yzWZriO6i2odGWWQVucZqKVsENW91IOW4vqudngPZsY3 - GvQ/xVA8/7pyFj6b7Esga60zyGW6LFe9r8n6paHrlG5o - jqf0BaqHT+8= ) -key02 KEY HOST|FLAG4 DNSSEC RSAMD5 ( - AQMFD5raczCJHViKtLYhWGz8hMY9UGRuniJDBzC7w0aR - yzWZriO6i2odGWWQVucZqKVsENW91IOW4vqudngPZsY3 - GvQ/xVA8/7pyFj6b7Esga60zyGW6LFe9r8n6paHrlG5o - jqf0BaqHT+8= ) +;; dnspython no longer supports old DNSSEC +;;key01 KEY 512 255 1 ( +;; AQMFD5raczCJHViKtLYhWGz8hMY9UGRuniJDBzC7w0aR +;; yzWZriO6i2odGWWQVucZqKVsENW91IOW4vqudngPZsY3 +;; GvQ/xVA8/7pyFj6b7Esga60zyGW6LFe9r8n6paHrlG5o +;; jqf0BaqHT+8= ) +;;key02 KEY HOST|FLAG4 DNSSEC RSAMD5 ( +;; AQMFD5raczCJHViKtLYhWGz8hMY9UGRuniJDBzC7w0aR +;; yzWZriO6i2odGWWQVucZqKVsENW91IOW4vqudngPZsY3 +;; GvQ/xVA8/7pyFj6b7Esga60zyGW6LFe9r8n6paHrlG5o +;; jqf0BaqHT+8= ) kx01 KX 10 kdc kx02 KX 10 . loc01 LOC 60 9 0.000 N 24 39 0.000 E 10.00m 20m 2000m 20m @@ -137,10 +138,10 @@ nsap-ptr01 NSAP-PTR foo. NSAP-PTR . nsap01 NSAP 0x47000580005a0000000001e133ffffff00016100 nsap02 NSAP 0x47.000580005a0000000001e133ffffff000161.00 -nxt01 NXT a.secure ( NS SOA MX SIG KEY LOC NXT ) -nxt02 NXT . ( NSAP-PTR NXT ) -nxt03 NXT . ( A ) -nxt04 NXT . ( 127 ) +;;nxt01 NXT a.secure ( NS SOA MX SIG KEY LOC NXT ) +;;nxt02 NXT . ( NSAP-PTR NXT ) +;;nxt03 NXT . ( A ) +;;nxt04 NXT . ( 127 ) ptr01 PTR example. px01 PX 65535 foo. bar. px02 PX 65535 . . @@ -154,11 +155,11 @@ $ORIGIN s.example. ns A 73.80.65.49 $ORIGIN example. $TTL 3600 ; 1 hour -sig01 SIG NXT 1 3 3600 ( - 20200101000000 20030101000000 2143 foo - MxFcby9k/yvedMfQgKzhH5er0Mu/vILz45IkskceFGgi - WCn/GxHhai6VAuHAoNUz4YoU1tVfSCSqQYn6//11U6Nl - d80jEeC8aTrO+KKmCaY= ) +;;sig01 SIG NXT 1 3 3600 ( +;; 20200101000000 20030101000000 2143 foo +;; MxFcby9k/yvedMfQgKzhH5er0Mu/vILz45IkskceFGgi +;; WCn/GxHhai6VAuHAoNUz4YoU1tVfSCSqQYn6//11U6Nl +;; d80jEeC8aTrO+KKmCaY= ) srv01 SRV 0 0 0 . srv02 SRV 65535 65535 65535 old-slow-box.example.com. $TTL 301 ; 5 minutes 1 second @@ -202,7 +203,7 @@ dnskey01 DNSKEY 512 255 1 ( yzWZriO6i2odGWWQVucZqKVsENW91IOW4vqudngPZsY3 GvQ/xVA8/7pyFj6b7Esga60zyGW6LFe9r8n6paHrlG5o jqf0BaqHT+8= ) -dnskey02 DNSKEY HOST|FLAG4 DNSSEC RSAMD5 ( +dnskey02 DNSKEY 257 3 RSAMD5 ( AQMFD5raczCJHViKtLYhWGz8hMY9UGRuniJDBzC7w0aR yzWZriO6i2odGWWQVucZqKVsENW91IOW4vqudngPZsY3 GvQ/xVA8/7pyFj6b7Esga60zyGW6LFe9r8n6paHrlG5o diff --git a/tests/example1.good b/tests/example1.good index ca5ead63..0834d171 100644 --- a/tests/example1.good +++ b/tests/example1.good @@ -27,7 +27,7 @@ dname01 3600 IN DNAME dname-target. dname02 3600 IN DNAME dname-target dname03 3600 IN DNAME . dnskey01 3600 IN DNSKEY 512 255 1 AQMFD5raczCJHViKtLYhWGz8hMY9UGRu niJDBzC7w0aRyzWZriO6i2odGWWQVucZ qKVsENW91IOW4vqudngPZsY3GvQ/xVA8 /7pyFj6b7Esga60zyGW6LFe9r8n6paHr lG5ojqf0BaqHT+8= -dnskey02 3600 IN DNSKEY 2560 3 1 AQMFD5raczCJHViKtLYhWGz8hMY9UGRu niJDBzC7w0aRyzWZriO6i2odGWWQVucZ qKVsENW91IOW4vqudngPZsY3GvQ/xVA8 /7pyFj6b7Esga60zyGW6LFe9r8n6paHr lG5ojqf0BaqHT+8= +dnskey02 3600 IN DNSKEY 257 3 1 AQMFD5raczCJHViKtLYhWGz8hMY9UGRu niJDBzC7w0aRyzWZriO6i2odGWWQVucZ qKVsENW91IOW4vqudngPZsY3GvQ/xVA8 /7pyFj6b7Esga60zyGW6LFe9r8n6paHr lG5ojqf0BaqHT+8= ds01 3600 IN DS 12345 3 1 123456789abcdef67890123456789abcdef67890 e 300 IN MX 10 mail e 300 IN TXT "one" @@ -51,8 +51,6 @@ isdn01 3600 IN ISDN "isdn-address" isdn02 3600 IN ISDN "isdn-address" "subaddress" isdn03 3600 IN ISDN "isdn-address" isdn04 3600 IN ISDN "isdn-address" "subaddress" -key01 3600 IN KEY 512 255 1 AQMFD5raczCJHViKtLYhWGz8hMY9UGRu niJDBzC7w0aRyzWZriO6i2odGWWQVucZ qKVsENW91IOW4vqudngPZsY3GvQ/xVA8 /7pyFj6b7Esga60zyGW6LFe9r8n6paHr lG5ojqf0BaqHT+8= -key02 3600 IN KEY 2560 3 1 AQMFD5raczCJHViKtLYhWGz8hMY9UGRu niJDBzC7w0aRyzWZriO6i2odGWWQVucZ qKVsENW91IOW4vqudngPZsY3GvQ/xVA8 /7pyFj6b7Esga60zyGW6LFe9r8n6paHr lG5ojqf0BaqHT+8= kx01 3600 IN KX 10 kdc kx02 3600 IN KX 10 . loc01 3600 IN LOC 60 9 0.000 N 24 39 0.000 E 10.00m 20.00m 2000.00m 20.00m @@ -77,10 +75,6 @@ nsec301 3600 IN NSEC3 1 1 12 aabbccdd 2t7b4g4vsa5smi47k61mv5bv1a22bojr NS SOA MX nsec302 3600 IN NSEC3 1 1 12 - 2t7b4g4vsa5smi47k61mv5bv1a22bojr NS SOA MX RRSIG DNSKEY NSEC3PARAM nsec3param01 3600 IN NSEC3PARAM 1 1 12 aabbccdd nsec3param02 3600 IN NSEC3PARAM 1 1 12 - -nxt01 3600 IN NXT a.secure NS SOA MX SIG KEY LOC NXT -nxt02 3600 IN NXT . NSAP-PTR NXT -nxt03 3600 IN NXT . A -nxt04 3600 IN NXT . TYPE127 ptr01 3600 IN PTR @ px01 3600 IN PX 65535 foo. bar. px02 3600 IN PX 65535 . . @@ -91,7 +85,6 @@ rt01 3600 IN RT 0 intermediate-host rt02 3600 IN RT 65535 . s 300 IN NS ns.s ns.s 300 IN A 73.80.65.49 -sig01 3600 IN SIG NXT 1 3 3600 20200101000000 20030101000000 2143 foo MxFcby9k/yvedMfQgKzhH5er0Mu/vILz 45IkskceFGgiWCn/GxHhai6VAuHAoNUz 4YoU1tVfSCSqQYn6//11U6Nld80jEeC8 aTrO+KKmCaY= spf 3600 IN SPF "v=spf1 mx -all" srv01 3600 IN SRV 0 0 0 . srv02 3600 IN SRV 65535 65535 65535 old-slow-box.example.com. diff --git a/tests/example2.good b/tests/example2.good index c923c09b..de4bcd59 100644 --- a/tests/example2.good +++ b/tests/example2.good @@ -27,7 +27,7 @@ dname01.example. 3600 IN DNAME dname-target. dname02.example. 3600 IN DNAME dname-target.example. dname03.example. 3600 IN DNAME . dnskey01.example. 3600 IN DNSKEY 512 255 1 AQMFD5raczCJHViKtLYhWGz8hMY9UGRu niJDBzC7w0aRyzWZriO6i2odGWWQVucZ qKVsENW91IOW4vqudngPZsY3GvQ/xVA8 /7pyFj6b7Esga60zyGW6LFe9r8n6paHr lG5ojqf0BaqHT+8= -dnskey02.example. 3600 IN DNSKEY 2560 3 1 AQMFD5raczCJHViKtLYhWGz8hMY9UGRu niJDBzC7w0aRyzWZriO6i2odGWWQVucZ qKVsENW91IOW4vqudngPZsY3GvQ/xVA8 /7pyFj6b7Esga60zyGW6LFe9r8n6paHr lG5ojqf0BaqHT+8= +dnskey02.example. 3600 IN DNSKEY 257 3 1 AQMFD5raczCJHViKtLYhWGz8hMY9UGRu niJDBzC7w0aRyzWZriO6i2odGWWQVucZ qKVsENW91IOW4vqudngPZsY3GvQ/xVA8 /7pyFj6b7Esga60zyGW6LFe9r8n6paHr lG5ojqf0BaqHT+8= ds01.example. 3600 IN DS 12345 3 1 123456789abcdef67890123456789abcdef67890 e.example. 300 IN MX 10 mail.example. e.example. 300 IN TXT "one" @@ -51,8 +51,6 @@ isdn01.example. 3600 IN ISDN "isdn-address" isdn02.example. 3600 IN ISDN "isdn-address" "subaddress" isdn03.example. 3600 IN ISDN "isdn-address" isdn04.example. 3600 IN ISDN "isdn-address" "subaddress" -key01.example. 3600 IN KEY 512 255 1 AQMFD5raczCJHViKtLYhWGz8hMY9UGRu niJDBzC7w0aRyzWZriO6i2odGWWQVucZ qKVsENW91IOW4vqudngPZsY3GvQ/xVA8 /7pyFj6b7Esga60zyGW6LFe9r8n6paHr lG5ojqf0BaqHT+8= -key02.example. 3600 IN KEY 2560 3 1 AQMFD5raczCJHViKtLYhWGz8hMY9UGRu niJDBzC7w0aRyzWZriO6i2odGWWQVucZ qKVsENW91IOW4vqudngPZsY3GvQ/xVA8 /7pyFj6b7Esga60zyGW6LFe9r8n6paHr lG5ojqf0BaqHT+8= kx01.example. 3600 IN KX 10 kdc.example. kx02.example. 3600 IN KX 10 . loc01.example. 3600 IN LOC 60 9 0.000 N 24 39 0.000 E 10.00m 20.00m 2000.00m 20.00m @@ -77,10 +75,6 @@ nsec301.example. 3600 IN NSEC3 1 1 12 aabbccdd 2t7b4g4vsa5smi47k61mv5bv1a22bojr nsec302.example. 3600 IN NSEC3 1 1 12 - 2t7b4g4vsa5smi47k61mv5bv1a22bojr NS SOA MX RRSIG DNSKEY NSEC3PARAM nsec3param01.example. 3600 IN NSEC3PARAM 1 1 12 aabbccdd nsec3param02.example. 3600 IN NSEC3PARAM 1 1 12 - -nxt01.example. 3600 IN NXT a.secure.example. NS SOA MX SIG KEY LOC NXT -nxt02.example. 3600 IN NXT . NSAP-PTR NXT -nxt03.example. 3600 IN NXT . A -nxt04.example. 3600 IN NXT . TYPE127 ptr01.example. 3600 IN PTR example. px01.example. 3600 IN PX 65535 foo. bar. px02.example. 3600 IN PX 65535 . . @@ -91,7 +85,6 @@ rt01.example. 3600 IN RT 0 intermediate-host.example. rt02.example. 3600 IN RT 65535 . s.example. 300 IN NS ns.s.example. ns.s.example. 300 IN A 73.80.65.49 -sig01.example. 3600 IN SIG NXT 1 3 3600 20200101000000 20030101000000 2143 foo.example. MxFcby9k/yvedMfQgKzhH5er0Mu/vILz 45IkskceFGgiWCn/GxHhai6VAuHAoNUz 4YoU1tVfSCSqQYn6//11U6Nld80jEeC8 aTrO+KKmCaY= spf.example. 3600 IN SPF "v=spf1 mx -all" srv01.example. 3600 IN SRV 0 0 0 . srv02.example. 3600 IN SRV 65535 65535 65535 old-slow-box.example.com. diff --git a/tests/flags.py b/tests/flags.py index 7ee2d8e1..824683e8 100644 --- a/tests/flags.py +++ b/tests/flags.py @@ -22,37 +22,37 @@ import dns.opcode class FlagsTestCase(unittest.TestCase): def test_rcode1(self): - self.failUnless(dns.rcode.from_text('FORMERR') == dns.rcode.FORMERR) + self.assertTrue(dns.rcode.from_text('FORMERR') == dns.rcode.FORMERR) def test_rcode2(self): - self.failUnless(dns.rcode.to_text(dns.rcode.FORMERR) == "FORMERR") + self.assertTrue(dns.rcode.to_text(dns.rcode.FORMERR) == "FORMERR") def test_rcode3(self): - self.failUnless(dns.rcode.to_flags(dns.rcode.FORMERR) == (1, 0)) + self.assertTrue(dns.rcode.to_flags(dns.rcode.FORMERR) == (1, 0)) def test_rcode4(self): - self.failUnless(dns.rcode.to_flags(dns.rcode.BADVERS) == \ + self.assertTrue(dns.rcode.to_flags(dns.rcode.BADVERS) == \ (0, 0x01000000)) def test_rcode6(self): - self.failUnless(dns.rcode.from_flags(0, 0x01000000) == \ + self.assertTrue(dns.rcode.from_flags(0, 0x01000000) == \ dns.rcode.BADVERS) def test_rcode6(self): - self.failUnless(dns.rcode.from_flags(5, 0) == dns.rcode.REFUSED) + self.assertTrue(dns.rcode.from_flags(5, 0) == dns.rcode.REFUSED) def test_rcode7(self): def bad(): dns.rcode.to_flags(4096) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_flags1(self): - self.failUnless(dns.flags.from_text("RA RD AA QR") == \ + self.assertTrue(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.failUnless(dns.flags.to_text(flags) == "QR AA RD RA") + self.assertTrue(dns.flags.to_text(flags) == "QR AA RD RA") if __name__ == '__main__': diff --git a/tests/message.py b/tests/message.py index e4b08587..b8fb18ed 100644 --- a/tests/message.py +++ b/tests/message.py @@ -90,41 +90,41 @@ class MessageTestCase(unittest.TestCase): def test_comparison_eq1(self): q1 = dns.message.from_text(query_text) q2 = dns.message.from_text(query_text) - self.failUnless(q1 == q2) + self.assertTrue(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.failUnless(q1 != q2) + self.assertTrue(q1 != q2) def test_comparison_ne2(self): q1 = dns.message.from_text(query_text) q2 = dns.message.from_text(query_text) q2.question = [] - self.failUnless(q1 != q2) + self.assertTrue(q1 != q2) def test_comparison_ne3(self): q1 = dns.message.from_text(query_text) - self.failUnless(q1 != 1) + self.assertTrue(q1 != 1) def test_EDNS_to_wire1(self): q = dns.message.from_text(query_text) w = q.to_wire() - self.failUnless(w == goodwire) + self.assertTrue(w == goodwire) def test_EDNS_from_wire1(self): m = dns.message.from_wire(goodwire) - self.failUnless(str(m) == query_text) + self.assertTrue(str(m) == query_text) def test_EDNS_to_wire2(self): q = dns.message.from_text(query_text_2) w = q.to_wire() - self.failUnless(w == goodwire3) + self.assertTrue(w == goodwire3) def test_EDNS_from_wire2(self): m = dns.message.from_wire(goodwire3) - self.failUnless(str(m) == query_text_2) + self.assertTrue(str(m) == query_text_2) def test_TooBig(self): def bad(): @@ -136,43 +136,43 @@ class MessageTestCase(unittest.TestCase): '10.0.0.%d' % i) q.additional.append(rrset) w = 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) wire = a.to_wire(want_shuffle=False) - self.failUnless(wire == goodwire2) + self.assertTrue(wire == goodwire2) def test_TrailingJunk(self): def bad(): badwire = goodwire + b'\x00' m = 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 m = 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) r2 = 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') m.set_rcode(4095) - self.failUnless(m.rcode() == 4095) + self.assertTrue(m.rcode() == 4095) m.set_rcode(2) - self.failUnless(m.rcode() == 2) + self.assertTrue(m.rcode() == 2) def test_EDNSVersionCoherence(self): m = dns.message.make_query('foo', 'A') m.use_edns(1) - self.failUnless((m.ednsflags >> 16) & 0xFF == 1) + self.assertTrue((m.ednsflags >> 16) & 0xFF == 1) if __name__ == '__main__': unittest.main() diff --git a/tests/name.py b/tests/name.py index bf05a91b..76573504 100644 --- a/tests/name.py +++ b/tests/name.py @@ -29,27 +29,27 @@ class NameTestCase(unittest.TestCase): def testFromTextRel1(self): n = dns.name.from_text('foo.bar') - self.failUnless(n.labels == (b'foo', b'bar', b'')) + self.assertTrue(n.labels == (b'foo', b'bar', b'')) def testFromTextRel2(self): n = dns.name.from_text('foo.bar', origin=self.origin) - self.failUnless(n.labels == (b'foo', b'bar', b'example', b'')) + self.assertTrue(n.labels == (b'foo', b'bar', b'example', b'')) def testFromTextRel3(self): n = dns.name.from_text('foo.bar', origin=None) - self.failUnless(n.labels == (b'foo', b'bar')) + self.assertTrue(n.labels == (b'foo', b'bar')) def testFromTextRel4(self): n = dns.name.from_text('@', origin=None) - self.failUnless(n == dns.name.empty) + self.assertTrue(n == dns.name.empty) def testFromTextRel5(self): n = dns.name.from_text('@', origin=self.origin) - self.failUnless(n == self.origin) + self.assertTrue(n == self.origin) def testFromTextAbs1(self): n = dns.name.from_text('foo.bar.') - self.failUnless(n.labels == (b'foo', b'bar', b'')) + self.assertTrue(n.labels == (b'foo', b'bar', b'')) def testTortureFromText(self): good = [ @@ -97,275 +97,275 @@ 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] = b'foo' - self.failUnlessRaises(TypeError, bad) + self.assertRaises(TypeError, bad) def testAbs1(self): - self.failUnless(dns.name.root.is_absolute()) + self.assertTrue(dns.name.root.is_absolute()) def testAbs2(self): - self.failUnless(not dns.name.empty.is_absolute()) + self.assertTrue(not dns.name.empty.is_absolute()) def testAbs3(self): - self.failUnless(self.origin.is_absolute()) + self.assertTrue(self.origin.is_absolute()) def testAbs3(self): n = dns.name.from_text('foo', origin=None) - self.failUnless(not n.is_absolute()) + self.assertTrue(not n.is_absolute()) def testWild1(self): n = dns.name.from_text('*.foo', origin=None) - self.failUnless(n.is_wild()) + self.assertTrue(n.is_wild()) def testWild2(self): n = dns.name.from_text('*a.foo', origin=None) - self.failUnless(not n.is_wild()) + self.assertTrue(not n.is_wild()) def testWild3(self): n = dns.name.from_text('a.*.foo', origin=None) - self.failUnless(not n.is_wild()) + self.assertTrue(not n.is_wild()) def testWild4(self): - self.failUnless(not dns.name.root.is_wild()) + self.assertTrue(not dns.name.root.is_wild()) def testWild5(self): - self.failUnless(not dns.name.empty.is_wild()) + self.assertTrue(not dns.name.empty.is_wild()) def testHash1(self): n1 = dns.name.from_text('fOo.COM') n2 = dns.name.from_text('foo.com') - self.failUnless(hash(n1) == hash(n2)) + self.assertTrue(hash(n1) == hash(n2)) def testCompare1(self): n1 = dns.name.from_text('a') n2 = dns.name.from_text('b') - self.failUnless(n1 < n2) - self.failUnless(n2 > n1) + self.assertTrue(n1 < n2) + self.assertTrue(n2 > n1) def testCompare2(self): n1 = dns.name.from_text('') n2 = dns.name.from_text('b') - self.failUnless(n1 < n2) - self.failUnless(n2 > n1) + self.assertTrue(n1 < n2) + self.assertTrue(n2 > n1) def testCompare3(self): - self.failUnless(dns.name.empty < dns.name.root) - self.failUnless(dns.name.root > dns.name.empty) + self.assertTrue(dns.name.empty < dns.name.root) + self.assertTrue(dns.name.root > dns.name.empty) def testCompare4(self): - self.failUnless(dns.name.root != 1) + self.assertTrue(dns.name.root != 1) def testSubdomain1(self): - self.failUnless(not dns.name.empty.is_subdomain(dns.name.root)) + self.assertTrue(not dns.name.empty.is_subdomain(dns.name.root)) def testSubdomain2(self): - self.failUnless(not dns.name.root.is_subdomain(dns.name.empty)) + self.assertTrue(not dns.name.root.is_subdomain(dns.name.empty)) def testSubdomain3(self): n = dns.name.from_text('foo', origin=self.origin) - self.failUnless(n.is_subdomain(self.origin)) + self.assertTrue(n.is_subdomain(self.origin)) def testSubdomain4(self): n = dns.name.from_text('foo', origin=self.origin) - self.failUnless(n.is_subdomain(dns.name.root)) + self.assertTrue(n.is_subdomain(dns.name.root)) def testSubdomain5(self): n = dns.name.from_text('foo', origin=self.origin) - self.failUnless(n.is_subdomain(n)) + self.assertTrue(n.is_subdomain(n)) def testSuperdomain1(self): - self.failUnless(not dns.name.empty.is_superdomain(dns.name.root)) + self.assertTrue(not dns.name.empty.is_superdomain(dns.name.root)) def testSuperdomain2(self): - self.failUnless(not dns.name.root.is_superdomain(dns.name.empty)) + self.assertTrue(not dns.name.root.is_superdomain(dns.name.empty)) def testSuperdomain3(self): n = dns.name.from_text('foo', origin=self.origin) - self.failUnless(self.origin.is_superdomain(n)) + self.assertTrue(self.origin.is_superdomain(n)) def testSuperdomain4(self): n = dns.name.from_text('foo', origin=self.origin) - self.failUnless(dns.name.root.is_superdomain(n)) + self.assertTrue(dns.name.root.is_superdomain(n)) def testSuperdomain5(self): n = dns.name.from_text('foo', origin=self.origin) - self.failUnless(n.is_superdomain(n)) + self.assertTrue(n.is_superdomain(n)) def testCanonicalize1(self): n = dns.name.from_text('FOO.bar', origin=self.origin) c = n.canonicalize() - self.failUnless(c.labels == (b'foo', b'bar', b'example', b'')) + self.assertTrue(c.labels == (b'foo', b'bar', b'example', b'')) def testToText1(self): n = dns.name.from_text('FOO.bar', origin=self.origin) t = n.to_text() - self.failUnless(t == 'FOO.bar.example.') + self.assertTrue(t == 'FOO.bar.example.') def testToText2(self): n = dns.name.from_text('FOO.bar', origin=self.origin) t = n.to_text(True) - self.failUnless(t == 'FOO.bar.example') + self.assertTrue(t == 'FOO.bar.example') def testToText3(self): n = dns.name.from_text('FOO.bar', origin=None) t = n.to_text() - self.failUnless(t == 'FOO.bar') + self.assertTrue(t == 'FOO.bar') def testToText4(self): t = dns.name.empty.to_text() - self.failUnless(t == '@') + self.assertTrue(t == '@') def testToText5(self): t = dns.name.root.to_text() - self.failUnless(t == '.') + self.assertTrue(t == '.') def testToText6(self): n = dns.name.from_text('FOO bar', origin=None) t = n.to_text() - self.failUnless(t == r'FOO\032bar') + self.assertTrue(t == r'FOO\032bar') def testToText7(self): n = dns.name.from_text(r'FOO\.bar', origin=None) t = n.to_text() - self.failUnless(t == r'FOO\.bar') + self.assertTrue(t == r'FOO\.bar') def testToText8(self): n = dns.name.from_text(r'\070OO\.bar', origin=None) t = n.to_text() - self.failUnless(t == r'FOO\.bar') + self.assertTrue(t == r'FOO\.bar') def testSlice1(self): n = dns.name.from_text(r'a.b.c.', origin=None) s = n[:] - self.failUnless(s == (b'a', b'b', b'c', b'')) + self.assertTrue(s == (b'a', b'b', b'c', b'')) def testSlice2(self): n = dns.name.from_text(r'a.b.c.', origin=None) s = n[:2] - self.failUnless(s == (b'a', b'b')) + self.assertTrue(s == (b'a', b'b')) def testSlice3(self): n = dns.name.from_text(r'a.b.c.', origin=None) s = n[2:] - self.failUnless(s == (b'c', b'')) + self.assertTrue(s == (b'c', b'')) def testEmptyLabel1(self): def bad(): n = dns.name.Name(['a', '', 'b']) - self.failUnlessRaises(dns.name.EmptyLabel, bad) + self.assertRaises(dns.name.EmptyLabel, bad) def testEmptyLabel2(self): def bad(): n = dns.name.Name(['', 'b']) - self.failUnlessRaises(dns.name.EmptyLabel, bad) + self.assertRaises(dns.name.EmptyLabel, bad) def testEmptyLabel3(self): n = dns.name.Name(['b', '']) - self.failUnless(n) + self.assertTrue(n) def testLongLabel(self): n = dns.name.Name(['a' * 63]) - self.failUnless(n) + self.assertTrue(n) def testLabelTooLong(self): def bad(): n = 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]) - self.failUnless(n) + self.assertTrue(n) def testNameTooLong(self): def bad(): n = 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']) n2 = dns.name.Name(['c', 'd']) e = dns.name.Name(['a', 'b', 'c', 'd']) r = n1 + n2 - self.failUnless(r == e) + self.assertTrue(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.failUnless(r == e) + self.assertTrue(r == e) def testConcat2(self): n1 = dns.name.Name([]) n2 = dns.name.Name(['a', 'b']) e = dns.name.Name(['a', 'b']) r = n1 + n2 - self.failUnless(r == e) + self.assertTrue(r == e) def testConcat3(self): n1 = dns.name.Name(['a', 'b', '']) n2 = dns.name.Name([]) e = dns.name.Name(['a', 'b', '']) r = n1 + n2 - self.failUnless(r == e) + self.assertTrue(r == e) def testConcat4(self): n1 = dns.name.Name(['a', 'b']) n2 = dns.name.Name(['c', '']) e = dns.name.Name(['a', 'b', 'c', '']) r = n1 + n2 - self.failUnless(r == e) + self.assertTrue(r == e) def testConcat5(self): def bad(): n1 = dns.name.Name(['a', 'b', '']) n2 = dns.name.Name(['c']) r = 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') d = n.to_digestable() - self.failUnless(d == b'\x03foo\x03bar\x00') + self.assertTrue(d == b'\x03foo\x03bar\x00') def testDigestable2(self): n1 = dns.name.from_text('FOO.bar') n2 = dns.name.from_text('foo.BAR.') d1 = n1.to_digestable() d2 = n2.to_digestable() - self.failUnless(d1 == d2) + self.assertTrue(d1 == d2) def testDigestable3(self): d = dns.name.root.to_digestable() - self.failUnless(d == b'\x00') + self.assertTrue(d == b'\x00') def testDigestable4(self): n = dns.name.from_text('FOO.bar', None) d = n.to_digestable(dns.name.root) - self.failUnless(d == b'\x03foo\x03bar\x00') + self.assertTrue(d == b'\x03foo\x03bar\x00') def testBadDigestable(self): def bad(): n = dns.name.from_text('FOO.bar', None) d = 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') f = io.BytesIO() compress = {} n.to_wire(f, compress) - self.failUnless(f.getvalue() == b'\x03FOO\x03bar\x00') + self.assertTrue(f.getvalue() == b'\x03FOO\x03bar\x00') def testToWire2(self): n = dns.name.from_text('FOO.bar') @@ -373,7 +373,7 @@ class NameTestCase(unittest.TestCase): compress = {} n.to_wire(f, compress) n.to_wire(f, compress) - self.failUnless(f.getvalue() == b'\x03FOO\x03bar\x00\xc0\x00') + self.assertTrue(f.getvalue() == b'\x03FOO\x03bar\x00\xc0\x00') def testToWire3(self): n1 = dns.name.from_text('FOO.bar') @@ -382,7 +382,7 @@ class NameTestCase(unittest.TestCase): compress = {} n1.to_wire(f, compress) n2.to_wire(f, compress) - self.failUnless(f.getvalue() == b'\x03FOO\x03bar\x00\xc0\x00') + self.assertTrue(f.getvalue() == b'\x03FOO\x03bar\x00\xc0\x00') def testToWire4(self): n1 = dns.name.from_text('FOO.bar') @@ -391,7 +391,7 @@ class NameTestCase(unittest.TestCase): compress = {} n1.to_wire(f, compress) n2.to_wire(f, compress) - self.failUnless(f.getvalue() == b'\x03FOO\x03bar\x00\x01\x61\xc0\x00') + self.assertTrue(f.getvalue() == b'\x03FOO\x03bar\x00\x01\x61\xc0\x00') def testToWire5(self): n1 = dns.name.from_text('FOO.bar') @@ -400,13 +400,13 @@ class NameTestCase(unittest.TestCase): compress = {} n1.to_wire(f, compress) n2.to_wire(f, None) - self.failUnless(f.getvalue() == \ + self.assertTrue(f.getvalue() == \ b'\x03FOO\x03bar\x00\x01\x61\x03foo\x03bar\x00') def testToWire6(self): n = dns.name.from_text('FOO.bar') v = n.to_wire() - self.failUnless(v == b'\x03FOO\x03bar\x00') + self.assertTrue(v == b'\x03FOO\x03bar\x00') def testBadToWire(self): def bad(): @@ -414,131 +414,131 @@ class NameTestCase(unittest.TestCase): f = io.BytesIO() compress = {} 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.') (prefix, suffix) = n.split(2) ep = dns.name.from_text('foo', None) es = dns.name.from_text('bar.', None) - self.failUnless(prefix == ep and suffix == es) + self.assertTrue(prefix == ep and 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.failUnless(prefix == ep and suffix == es) + self.assertTrue(prefix == ep and 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.failUnless(prefix == ep and suffix == es) + self.assertTrue(prefix == ep and 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.failUnless(prefix == ep and suffix == es) + self.assertTrue(prefix == ep and suffix == es) def testBadSplit1(self): def bad(): n = dns.name.from_text('foo.bar.') (prefix, suffix) = n.split(-1) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def testBadSplit2(self): def bad(): n = dns.name.from_text('foo.bar.') (prefix, suffix) = n.split(4) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def testRelativize1(self): n = dns.name.from_text('a.foo.bar.', None) o = dns.name.from_text('bar.', None) e = dns.name.from_text('a.foo', None) - self.failUnless(n.relativize(o) == e) + self.assertTrue(n.relativize(o) == e) def testRelativize2(self): n = dns.name.from_text('a.foo.bar.', None) o = n e = dns.name.empty - self.failUnless(n.relativize(o) == e) + self.assertTrue(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.failUnless(n.relativize(o) == e) + self.assertTrue(n.relativize(o) == e) def testRelativize4(self): n = dns.name.from_text('a.foo', None) o = dns.name.root e = n - self.failUnless(n.relativize(o) == e) + self.assertTrue(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.failUnless(n.derelativize(o) == e) + self.assertTrue(n.derelativize(o) == e) def testDerelativize2(self): n = dns.name.empty o = dns.name.from_text('a.foo.bar.', None) e = o - self.failUnless(n.derelativize(o) == e) + self.assertTrue(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.failUnless(n.derelativize(o) == e) + self.assertTrue(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.failUnless(n.choose_relativity(o, True) == e) + self.assertTrue(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.failUnless(n.choose_relativity(o, False) == e) + self.assertTrue(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.failUnless(n.choose_relativity(o, False) == e) + self.assertTrue(n.choose_relativity(o, False) == e) def testChooseRelativity4(self): n = dns.name.from_text('a.foo', None) o = None e = n - self.failUnless(n.choose_relativity(o, True) == e) + self.assertTrue(n.choose_relativity(o, True) == e) def testChooseRelativity5(self): n = dns.name.from_text('a.foo', None) o = None e = n - self.failUnless(n.choose_relativity(o, False) == e) + self.assertTrue(n.choose_relativity(o, False) == e) def testChooseRelativity6(self): n = dns.name.from_text('a.foo.', None) o = None e = n - self.failUnless(n.choose_relativity(o, True) == e) + self.assertTrue(n.choose_relativity(o, True) == e) def testChooseRelativity7(self): n = dns.name.from_text('a.foo.', None) o = None e = n - self.failUnless(n.choose_relativity(o, False) == e) + self.assertTrue(n.choose_relativity(o, False) == e) def testFromWire1(self): w = b'\x03foo\x00\xc0\x00' @@ -548,7 +548,7 @@ class NameTestCase(unittest.TestCase): en2 = en1 ecused1 = 5 ecused2 = 2 - self.failUnless(n1 == en1 and cused1 == ecused1 and \ + self.assertTrue(n1 == en1 and cused1 == ecused1 and \ n2 == en2 and cused2 == ecused2) def testFromWire2(self): @@ -565,7 +565,7 @@ class NameTestCase(unittest.TestCase): ecused1 = 5 ecused2 = 4 ecused3 = 4 - self.failUnless(n1 == en1 and cused1 == ecused1 and \ + self.assertTrue(n1 == en1 and cused1 == ecused1 and \ n2 == en2 and cused2 == ecused2 and \ n3 == en3 and cused3 == ecused3) @@ -573,126 +573,126 @@ class NameTestCase(unittest.TestCase): def bad(): w = b'\x03foo\xc0\x04' (n, cused) = 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' (n, cused) = 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' (n, cused) = 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' (n, cused) = 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.') - self.failUnless(n.parent() == dns.name.from_text('bar.')) - self.failUnless(n.parent().parent() == dns.name.root) + self.assertTrue(n.parent() == dns.name.from_text('bar.')) + self.assertTrue(n.parent().parent() == dns.name.root) def testParent2(self): n = dns.name.from_text('foo.bar', None) - self.failUnless(n.parent() == dns.name.from_text('bar', None)) - self.failUnless(n.parent().parent() == dns.name.empty) + self.assertTrue(n.parent() == dns.name.from_text('bar', None)) + self.assertTrue(n.parent().parent() == dns.name.empty) def testParent3(self): 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') - self.failUnless(n.labels == (b'foo', b'bar', b'')) + self.assertTrue(n.labels == (b'foo', b'bar', b'')) def testFromUnicode2(self): n = dns.name.from_text('foo\u1234bar.bar') - self.failUnless(n.labels == (b'xn--foobar-r5z', b'bar', b'')) + self.assertTrue(n.labels == (b'xn--foobar-r5z', b'bar', b'')) def testFromUnicodeAlternateDot1(self): n = dns.name.from_text('foo\u3002bar') - self.failUnless(n.labels == (b'foo', b'bar', b'')) + self.assertTrue(n.labels == (b'foo', b'bar', b'')) def testFromUnicodeAlternateDot2(self): n = dns.name.from_text('foo\uff0ebar') - self.failUnless(n.labels == (b'foo', b'bar', b'')) + self.assertTrue(n.labels == (b'foo', b'bar', b'')) def testFromUnicodeAlternateDot3(self): n = dns.name.from_text('foo\uff61bar') - self.failUnless(n.labels == (b'foo', b'bar', b'')) + self.assertTrue(n.labels == (b'foo', b'bar', b'')) def testToUnicode1(self): n = dns.name.from_text('foo.bar') s = n.to_unicode() - self.failUnless(s == 'foo.bar.') + self.assertTrue(s == 'foo.bar.') def testToUnicode2(self): n = dns.name.from_text('foo\u1234bar.bar') s = n.to_unicode() - self.failUnless(s == 'foo\u1234bar.bar.') + self.assertTrue(s == 'foo\u1234bar.bar.') def testToUnicode3(self): n = dns.name.from_text('foo.bar') s = n.to_unicode() - self.failUnless(s == 'foo.bar.') + self.assertTrue(s == 'foo.bar.') def testReverseIPv4(self): e = dns.name.from_text('1.0.0.127.in-addr.arpa.') n = dns.reversename.from_address('127.0.0.1') - self.failUnless(e == n) + self.assertTrue(e == n) def testReverseIPv6(self): e = dns.name.from_text('1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa.') n = dns.reversename.from_address('::1') - self.failUnless(e == n) + self.assertTrue(e == n) def testBadReverseIPv4(self): def bad(): n = dns.reversename.from_address('127.0.foo.1') - self.failUnlessRaises(socket.error, bad) + self.assertRaises(socket.error, bad) def testBadReverseIPv6(self): def bad(): n = dns.reversename.from_address('::1::1') - self.failUnlessRaises(socket.error, bad) + self.assertRaises(socket.error, bad) def testForwardIPv4(self): n = dns.name.from_text('1.0.0.127.in-addr.arpa.') e = '127.0.0.1' text = dns.reversename.to_address(n) - self.failUnless(text == e) + self.assertTrue(text == e) def testForwardIPv6(self): n = dns.name.from_text('1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa.') e = '::1' text = dns.reversename.to_address(n) - self.failUnless(text == e) + self.assertTrue(text == e) def testE164ToEnum(self): text = '+1 650 555 1212' e = dns.name.from_text('2.1.2.1.5.5.5.0.5.6.1.e164.arpa.') n = dns.e164.from_e164(text) - self.failUnless(n == e) + self.assertTrue(n == e) def testEnumToE164(self): n = dns.name.from_text('2.1.2.1.5.5.5.0.5.6.1.e164.arpa.') e = '+16505551212' text = dns.e164.to_e164(n) - self.failUnless(text == e) + self.assertTrue(text == e) if __name__ == '__main__': unittest.main() diff --git a/tests/namedict.py b/tests/namedict.py index 02611421..16e4ac9f 100644 --- a/tests/namedict.py +++ b/tests/namedict.py @@ -33,70 +33,70 @@ class NameTestCase(unittest.TestCase): self.rndict[n2] = 2 def testDepth(self): - self.failUnless(self.ndict.max_depth == 3) + self.assertTrue(self.ndict.max_depth == 3) def testLookup1(self): k = dns.name.from_text('foo.bar.') - self.failUnless(self.ndict[k] == 1) + self.assertTrue(self.ndict[k] == 1) def testLookup2(self): k = dns.name.from_text('foo.bar.') - self.failUnless(self.ndict.get_deepest_match(k)[1] == 1) + self.assertTrue(self.ndict.get_deepest_match(k)[1] == 1) def testLookup3(self): k = dns.name.from_text('a.b.c.foo.bar.') - self.failUnless(self.ndict.get_deepest_match(k)[1] == 1) + self.assertTrue(self.ndict.get_deepest_match(k)[1] == 1) def testLookup4(self): k = dns.name.from_text('a.b.c.bar.') - self.failUnless(self.ndict.get_deepest_match(k)[1] == 2) + self.assertTrue(self.ndict.get_deepest_match(k)[1] == 2) def testLookup5(self): def bad(): n = dns.name.from_text('a.b.c.') (k, v) = self.ndict.get_deepest_match(n) - self.failUnlessRaises(KeyError, bad) + self.assertRaises(KeyError, bad) def testLookup6(self): def bad(): (k, v) = 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 n = dns.name.from_text('a.b.c.') (k, v) = self.ndict.get_deepest_match(n) - self.failUnless(v == 100) + self.assertTrue(v == 100) def testLookup8(self): def bad(): self.ndict['foo'] = 100 - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def testRelDepth(self): - self.failUnless(self.rndict.max_depth == 2) + self.assertTrue(self.rndict.max_depth == 2) def testRelLookup1(self): k = dns.name.from_text('foo.bar', None) - self.failUnless(self.rndict[k] == 1) + self.assertTrue(self.rndict[k] == 1) def testRelLookup2(self): k = dns.name.from_text('foo.bar', None) - self.failUnless(self.rndict.get_deepest_match(k)[1] == 1) + self.assertTrue(self.rndict.get_deepest_match(k)[1] == 1) def testRelLookup3(self): k = dns.name.from_text('a.b.c.foo.bar', None) - self.failUnless(self.rndict.get_deepest_match(k)[1] == 1) + self.assertTrue(self.rndict.get_deepest_match(k)[1] == 1) def testRelLookup4(self): k = dns.name.from_text('a.b.c.bar', None) - self.failUnless(self.rndict.get_deepest_match(k)[1] == 2) + self.assertTrue(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) (k, v) = self.rndict.get_deepest_match(n) - self.failUnless(v == 100) + self.assertTrue(v == 100) if __name__ == '__main__': unittest.main() diff --git a/tests/ntoaaton.py b/tests/ntoaaton.py index 022cac17..2a1b5eb9 100644 --- a/tests/ntoaaton.py +++ b/tests/ntoaaton.py @@ -22,135 +22,135 @@ class NtoAAtoNTestCase(unittest.TestCase): def test_aton1(self): a = dns.ipv6.inet_aton('::') - self.failUnless(a == b'\x00' * 16) + self.assertTrue(a == b'\x00' * 16) def test_aton2(self): a = dns.ipv6.inet_aton('::1') - self.failUnless(a == b'\x00' * 15 + b'\x01') + self.assertTrue(a == b'\x00' * 15 + b'\x01') def test_aton3(self): a = dns.ipv6.inet_aton('::10.0.0.1') - self.failUnless(a == b'\x00' * 12 + b'\x0a\x00\x00\x01') + self.assertTrue(a == b'\x00' * 12 + b'\x0a\x00\x00\x01') def test_aton4(self): a = dns.ipv6.inet_aton('abcd::dcba') - self.failUnless(a == b'\xab\xcd' + b'\x00' * 12 + b'\xdc\xba') + self.assertTrue(a == b'\xab\xcd' + b'\x00' * 12 + b'\xdc\xba') def test_aton5(self): a = dns.ipv6.inet_aton('1:2:3:4:5:6:7:8') - self.failUnless(a == \ + self.assertTrue(a == \ bytes.fromhex('00010002000300040005000600070008')) def test_bad_aton1(self): def bad(): a = dns.ipv6.inet_aton('abcd:dcba') - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def test_bad_aton2(self): def bad(): a = dns.ipv6.inet_aton('abcd::dcba::1') - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def test_bad_aton3(self): def bad(): a = dns.ipv6.inet_aton('1:2:3:4:5:6:7:8:9') - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def test_aton1(self): a = dns.ipv6.inet_aton('::') - self.failUnless(a == b'\x00' * 16) + self.assertTrue(a == b'\x00' * 16) def test_aton2(self): a = dns.ipv6.inet_aton('::1') - self.failUnless(a == b'\x00' * 15 + b'\x01') + self.assertTrue(a == b'\x00' * 15 + b'\x01') def test_aton3(self): a = dns.ipv6.inet_aton('::10.0.0.1') - self.failUnless(a == b'\x00' * 12 + b'\x0a\x00\x00\x01') + self.assertTrue(a == b'\x00' * 12 + b'\x0a\x00\x00\x01') def test_aton4(self): a = dns.ipv6.inet_aton('abcd::dcba') - self.failUnless(a == b'\xab\xcd' + b'\x00' * 12 + b'\xdc\xba') + self.assertTrue(a == b'\xab\xcd' + b'\x00' * 12 + b'\xdc\xba') def test_ntoa1(self): b = bytes.fromhex('00010002000300040005000600070008') t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == '1:2:3:4:5:6:7:8') + self.assertTrue(t == '1:2:3:4:5:6:7:8') def test_ntoa2(self): b = b'\x00' * 16 t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == '::') + self.assertTrue(t == '::') def test_ntoa3(self): b = b'\x00' * 15 + b'\x01' t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == '::1') + self.assertTrue(t == '::1') def test_ntoa4(self): b = b'\x80' + b'\x00' * 15 t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == '8000::') + self.assertTrue(t == '8000::') def test_ntoa5(self): b = b'\x01\xcd' + b'\x00' * 12 + b'\x03\xef' t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == '1cd::3ef') + self.assertTrue(t == '1cd::3ef') def test_ntoa6(self): b = bytes.fromhex('ffff00000000ffff000000000000ffff') t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == 'ffff:0:0:ffff::ffff') + self.assertTrue(t == 'ffff:0:0:ffff::ffff') def test_ntoa7(self): b = bytes.fromhex('00000000ffff000000000000ffffffff') t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == '0:0:ffff::ffff:ffff') + self.assertTrue(t == '0:0:ffff::ffff:ffff') def test_ntoa8(self): b = bytes.fromhex('ffff0000ffff00000000ffff00000000') t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == 'ffff:0:ffff::ffff:0:0') + self.assertTrue(t == 'ffff:0:ffff::ffff:0:0') def test_ntoa9(self): b = bytes.fromhex('0000000000000000000000000a000001') t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == '::10.0.0.1') + self.assertTrue(t == '::10.0.0.1') def test_ntoa10(self): b = bytes.fromhex('0000000000000000000000010a000001') t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == '::1:a00:1') + self.assertTrue(t == '::1:a00:1') def test_ntoa11(self): b = bytes.fromhex('00000000000000000000ffff0a000001') t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == '::ffff:10.0.0.1') + self.assertTrue(t == '::ffff:10.0.0.1') def test_ntoa12(self): b = bytes.fromhex('000000000000000000000000ffffffff') t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == '::255.255.255.255') + self.assertTrue(t == '::255.255.255.255') def test_ntoa13(self): b = bytes.fromhex('00000000000000000000ffffffffffff') t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == '::ffff:255.255.255.255') + self.assertTrue(t == '::ffff:255.255.255.255') def test_ntoa14(self): b = bytes.fromhex('0000000000000000000000000001ffff') t = dns.ipv6.inet_ntoa(b) - self.failUnless(t == '::0.1.255.255') + self.assertTrue(t == '::0.1.255.255') def test_bad_ntoa1(self): def bad(): a = dns.ipv6.inet_ntoa('') - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_bad_ntoa2(self): def bad(): a = dns.ipv6.inet_ntoa(b'\x00' * 17) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) if __name__ == '__main__': unittest.main() diff --git a/tests/rdtypeandclass.py b/tests/rdtypeandclass.py index 0c8a830e..b377f44a 100644 --- a/tests/rdtypeandclass.py +++ b/tests/rdtypeandclass.py @@ -21,103 +21,103 @@ import dns.rdatatype class RdTypeAndClassTestCase(unittest.TestCase): # Classes - + def test_class_meta1(self): - self.failUnless(dns.rdataclass.is_metaclass(dns.rdataclass.ANY)) + self.assertTrue(dns.rdataclass.is_metaclass(dns.rdataclass.ANY)) def test_class_meta2(self): - self.failUnless(not dns.rdataclass.is_metaclass(dns.rdataclass.IN)) + self.assertTrue(not dns.rdataclass.is_metaclass(dns.rdataclass.IN)) def test_class_bytext1(self): - self.failUnless(dns.rdataclass.from_text('IN') == dns.rdataclass.IN) + self.assertTrue(dns.rdataclass.from_text('IN') == dns.rdataclass.IN) def test_class_bytext2(self): - self.failUnless(dns.rdataclass.from_text('CLASS1') == + self.assertTrue(dns.rdataclass.from_text('CLASS1') == dns.rdataclass.IN) def test_class_bytext_bounds1(self): - self.failUnless(dns.rdataclass.from_text('CLASS0') == 0) - self.failUnless(dns.rdataclass.from_text('CLASS65535') == 65535) + self.assertTrue(dns.rdataclass.from_text('CLASS0') == 0) + self.assertTrue(dns.rdataclass.from_text('CLASS65535') == 65535) def test_class_bytext_bounds2(self): def bad(): junk = dns.rdataclass.from_text('CLASS65536') - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_class_bytext_unknown(self): def bad(): junk = dns.rdataclass.from_text('XXX') - self.failUnlessRaises(dns.rdataclass.UnknownRdataclass, bad) + self.assertRaises(dns.rdataclass.UnknownRdataclass, bad) def test_class_totext1(self): - self.failUnless(dns.rdataclass.to_text(dns.rdataclass.IN) == 'IN') + self.assertTrue(dns.rdataclass.to_text(dns.rdataclass.IN) == 'IN') def test_class_totext1(self): - self.failUnless(dns.rdataclass.to_text(999) == 'CLASS999') + self.assertTrue(dns.rdataclass.to_text(999) == 'CLASS999') def test_class_totext_bounds1(self): def bad(): junk = dns.rdataclass.to_text(-1) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_class_totext_bounds2(self): def bad(): junk = dns.rdataclass.to_text(65536) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) # Types - + def test_type_meta1(self): - self.failUnless(dns.rdatatype.is_metatype(dns.rdatatype.ANY)) + self.assertTrue(dns.rdatatype.is_metatype(dns.rdatatype.ANY)) def test_type_meta2(self): - self.failUnless(dns.rdatatype.is_metatype(dns.rdatatype.OPT)) + self.assertTrue(dns.rdatatype.is_metatype(dns.rdatatype.OPT)) def test_type_meta3(self): - self.failUnless(not dns.rdatatype.is_metatype(dns.rdatatype.A)) + self.assertTrue(not dns.rdatatype.is_metatype(dns.rdatatype.A)) def test_type_singleton1(self): - self.failUnless(dns.rdatatype.is_singleton(dns.rdatatype.SOA)) + self.assertTrue(dns.rdatatype.is_singleton(dns.rdatatype.SOA)) def test_type_singleton2(self): - self.failUnless(not dns.rdatatype.is_singleton(dns.rdatatype.A)) + self.assertTrue(not dns.rdatatype.is_singleton(dns.rdatatype.A)) def test_type_bytext1(self): - self.failUnless(dns.rdatatype.from_text('A') == dns.rdatatype.A) + self.assertTrue(dns.rdatatype.from_text('A') == dns.rdatatype.A) def test_type_bytext2(self): - self.failUnless(dns.rdatatype.from_text('TYPE1') == + self.assertTrue(dns.rdatatype.from_text('TYPE1') == dns.rdatatype.A) def test_type_bytext_bounds1(self): - self.failUnless(dns.rdatatype.from_text('TYPE0') == 0) - self.failUnless(dns.rdatatype.from_text('TYPE65535') == 65535) + self.assertTrue(dns.rdatatype.from_text('TYPE0') == 0) + self.assertTrue(dns.rdatatype.from_text('TYPE65535') == 65535) def test_type_bytext_bounds2(self): def bad(): junk = dns.rdatatype.from_text('TYPE65536') - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_type_bytext_unknown(self): def bad(): junk = dns.rdatatype.from_text('XXX') - self.failUnlessRaises(dns.rdatatype.UnknownRdatatype, bad) + self.assertRaises(dns.rdatatype.UnknownRdatatype, bad) def test_type_totext1(self): - self.failUnless(dns.rdatatype.to_text(dns.rdatatype.A) == 'A') + self.assertTrue(dns.rdatatype.to_text(dns.rdatatype.A) == 'A') def test_type_totext1(self): - self.failUnless(dns.rdatatype.to_text(999) == 'TYPE999') + self.assertTrue(dns.rdatatype.to_text(999) == 'TYPE999') def test_type_totext_bounds1(self): def bad(): junk = dns.rdatatype.to_text(-1) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) def test_type_totext_bounds2(self): def bad(): junk = dns.rdatatype.to_text(65536) - self.failUnlessRaises(ValueError, bad) + self.assertRaises(ValueError, bad) if __name__ == '__main__': unittest.main() diff --git a/tests/resolver.py b/tests/resolver.py index b88be8c3..457fa346 100644 --- a/tests/resolver.py +++ b/tests/resolver.py @@ -53,7 +53,7 @@ class BaseResolverTests(object): def testRead(self): f = io.StringIO(resolv_conf) r = dns.resolver.Resolver(f) - self.failUnless(r.nameservers == ['10.0.0.1', '10.0.0.2'] and + self.assertTrue(r.nameservers == ['10.0.0.1', '10.0.0.2'] and r.domain == dns.name.from_text('foo')) def testCacheExpiration(self): @@ -64,7 +64,7 @@ class BaseResolverTests(object): cache = dns.resolver.Cache() cache.put((name, dns.rdatatype.A, dns.rdataclass.IN), answer) time.sleep(2) - self.failUnless(cache.get((name, dns.rdatatype.A, dns.rdataclass.IN)) + self.assertTrue(cache.get((name, dns.rdatatype.A, dns.rdataclass.IN)) is None) def testCacheCleaning(self): @@ -75,32 +75,32 @@ class BaseResolverTests(object): cache = dns.resolver.Cache(cleaning_interval=1.0) cache.put((name, dns.rdatatype.A, dns.rdataclass.IN), answer) time.sleep(2) - self.failUnless(cache.get((name, dns.rdatatype.A, dns.rdataclass.IN)) + self.assertTrue(cache.get((name, dns.rdatatype.A, dns.rdataclass.IN)) is None) def testZoneForName1(self): name = dns.name.from_text('www.dnspython.org.') ezname = dns.name.from_text('dnspython.org.') zname = dns.resolver.zone_for_name(name) - self.failUnless(zname == ezname) + self.assertTrue(zname == ezname) 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.failUnless(zname == ezname) + self.assertTrue(zname == ezname) 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.failUnless(zname == ezname) + self.assertTrue(zname == ezname) def testZoneForName4(self): def bad(): name = dns.name.from_text('dnspython.org', None) zname = dns.resolver.zone_for_name(name) - self.failUnlessRaises(dns.resolver.NotAbsolute, bad) + self.assertRaises(dns.resolver.NotAbsolute, bad) class PollingMonkeyPatchMixin(object): def setUp(self): diff --git a/tests/rrset.py b/tests/rrset.py index 3cafbee8..9e4bf5cb 100644 --- a/tests/rrset.py +++ b/tests/rrset.py @@ -18,37 +18,37 @@ import unittest import dns.rrset 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.failUnless(r1 == r2) + self.assertTrue(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.failUnless(r1 == r2) + self.assertTrue(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.failUnless(r1 != r2) + self.assertTrue(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.failUnless(r1 != r2) + self.assertTrue(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.failUnless(r1 != r2) + self.assertTrue(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.failUnless(r1 != r2) + self.assertTrue(r1 != r2) if __name__ == '__main__': unittest.main() diff --git a/tests/set.py b/tests/set.py index e2bca51b..0c84c980 100644 --- a/tests/set.py +++ b/tests/set.py @@ -21,156 +21,156 @@ import dns.set S = dns.set.Set class SimpleSetTestCase(unittest.TestCase): - + def testLen1(self): s1 = S() - self.failUnless(len(s1) == 0) + self.assertTrue(len(s1) == 0) def testLen2(self): s1 = S([1, 2, 3]) - self.failUnless(len(s1) == 3) + self.assertTrue(len(s1) == 3) def testLen3(self): s1 = S([1, 2, 3, 3, 3]) - self.failUnless(len(s1) == 3) + self.assertTrue(len(s1) == 3) def testUnion1(self): s1 = S([1, 2, 3]) s2 = S([1, 2, 3]) e = S([1, 2, 3]) - self.failUnless(s1 | s2 == e) + self.assertTrue(s1 | s2 == e) def testUnion2(self): s1 = S([1, 2, 3]) s2 = S([]) e = S([1, 2, 3]) - self.failUnless(s1 | s2 == e) + self.assertTrue(s1 | s2 == e) def testUnion3(self): s1 = S([1, 2, 3]) s2 = S([3, 4]) e = S([1, 2, 3, 4]) - self.failUnless(s1 | s2 == e) + self.assertTrue(s1 | s2 == e) def testIntersection1(self): s1 = S([1, 2, 3]) s2 = S([1, 2, 3]) e = S([1, 2, 3]) - self.failUnless(s1 & s2 == e) + self.assertTrue(s1 & s2 == e) def testIntersection2(self): s1 = S([0, 1, 2, 3]) s2 = S([1, 2, 3, 4]) e = S([1, 2, 3]) - self.failUnless(s1 & s2 == e) + self.assertTrue(s1 & s2 == e) def testIntersection3(self): s1 = S([1, 2, 3]) s2 = S([]) e = S([]) - self.failUnless(s1 & s2 == e) + self.assertTrue(s1 & s2 == e) def testIntersection4(self): s1 = S([1, 2, 3]) s2 = S([5, 4]) e = S([]) - self.failUnless(s1 & s2 == e) + self.assertTrue(s1 & s2 == e) def testDifference1(self): s1 = S([1, 2, 3]) s2 = S([5, 4]) e = S([1, 2, 3]) - self.failUnless(s1 - s2 == e) + self.assertTrue(s1 - s2 == e) def testDifference2(self): s1 = S([1, 2, 3]) s2 = S([]) e = S([1, 2, 3]) - self.failUnless(s1 - s2 == e) + self.assertTrue(s1 - s2 == e) def testDifference3(self): s1 = S([1, 2, 3]) s2 = S([3, 2]) e = S([1]) - self.failUnless(s1 - s2 == e) + self.assertTrue(s1 - s2 == e) def testDifference4(self): s1 = S([1, 2, 3]) s2 = S([3, 2, 1]) e = S([]) - self.failUnless(s1 - s2 == e) + self.assertTrue(s1 - s2 == e) def testSubset1(self): s1 = S([1, 2, 3]) s2 = S([3, 2, 1]) - self.failUnless(s1.issubset(s2)) + self.assertTrue(s1.issubset(s2)) def testSubset2(self): s1 = S([1, 2, 3]) - self.failUnless(s1.issubset(s1)) + self.assertTrue(s1.issubset(s1)) def testSubset3(self): s1 = S([]) s2 = S([1, 2, 3]) - self.failUnless(s1.issubset(s2)) + self.assertTrue(s1.issubset(s2)) def testSubset4(self): s1 = S([1]) s2 = S([1, 2, 3]) - self.failUnless(s1.issubset(s2)) + self.assertTrue(s1.issubset(s2)) def testSubset5(self): s1 = S([]) s2 = S([]) - self.failUnless(s1.issubset(s2)) + self.assertTrue(s1.issubset(s2)) def testSubset6(self): s1 = S([1, 4]) s2 = S([1, 2, 3]) - self.failUnless(not s1.issubset(s2)) + self.assertTrue(not s1.issubset(s2)) def testSuperset1(self): s1 = S([1, 2, 3]) s2 = S([3, 2, 1]) - self.failUnless(s1.issuperset(s2)) + self.assertTrue(s1.issuperset(s2)) def testSuperset2(self): s1 = S([1, 2, 3]) - self.failUnless(s1.issuperset(s1)) + self.assertTrue(s1.issuperset(s1)) def testSuperset3(self): s1 = S([1, 2, 3]) s2 = S([]) - self.failUnless(s1.issuperset(s2)) + self.assertTrue(s1.issuperset(s2)) def testSuperset4(self): s1 = S([1, 2, 3]) s2 = S([1]) - self.failUnless(s1.issuperset(s2)) + self.assertTrue(s1.issuperset(s2)) def testSuperset5(self): s1 = S([]) s2 = S([]) - self.failUnless(s1.issuperset(s2)) + self.assertTrue(s1.issuperset(s2)) def testSuperset6(self): s1 = S([1, 2, 3]) s2 = S([1, 4]) - self.failUnless(not s1.issuperset(s2)) + self.assertTrue(not s1.issuperset(s2)) def testUpdate1(self): s1 = S([1, 2, 3]) u = (4, 5, 6) e = S([1, 2, 3, 4, 5, 6]) s1.update(u) - self.failUnless(s1 == e) + self.assertTrue(s1 == e) def testUpdate2(self): s1 = S([1, 2, 3]) u = [] e = S([1, 2, 3]) s1.update(u) - self.failUnless(s1 == e) + self.assertTrue(s1 == e) def testGetitem(self): s1 = S([1, 2, 3]) @@ -178,31 +178,31 @@ class SimpleSetTestCase(unittest.TestCase): i1 = s1[1] i2 = s1[2] s2 = S([i0, i1, i2]) - self.failUnless(s1 == s2) + self.assertTrue(s1 == s2) def testGetslice(self): s1 = S([1, 2, 3]) slice = s1[0:2] - self.failUnless(len(slice) == 2) + self.assertTrue(len(slice) == 2) item = s1[2] slice.append(item) s2 = S(slice) - self.failUnless(s1 == s2) + self.assertTrue(s1 == s2) def testDelitem(self): s1 = S([1, 2, 3]) del s1[0] i1 = s1[0] i2 = s1[1] - self.failUnless(i1 != i2) - self.failUnless(i1 == 1 or i1 == 2 or i1 == 3) - self.failUnless(i2 == 1 or i2 == 2 or i2 == 3) + self.assertTrue(i1 != i2) + self.assertTrue(i1 == 1 or i1 == 2 or i1 == 3) + self.assertTrue(i2 == 1 or i2 == 2 or i2 == 3) def testDelslice(self): s1 = S([1, 2, 3]) del s1[0:2] i1 = s1[0] - self.failUnless(i1 == 1 or i1 == 2 or i1 == 3) + self.assertTrue(i1 == 1 or i1 == 2 or i1 == 3) if __name__ == '__main__': unittest.main() diff --git a/tests/tokenizer.py b/tests/tokenizer.py index 4f4a1bdc..a558a6d8 100644 --- a/tests/tokenizer.py +++ b/tests/tokenizer.py @@ -25,117 +25,117 @@ class TokenizerTestCase(unittest.TestCase): def testQuotedString1(self): tok = dns.tokenizer.Tokenizer(r'"foo"') token = tok.get() - self.failUnless(token == Token(dns.tokenizer.QUOTED_STRING, 'foo')) + self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, 'foo')) def testQuotedString2(self): tok = dns.tokenizer.Tokenizer(r'""') token = tok.get() - self.failUnless(token == Token(dns.tokenizer.QUOTED_STRING, '')) + self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, '')) def testQuotedString3(self): tok = dns.tokenizer.Tokenizer(r'"\"foo\""') token = tok.get() - self.failUnless(token == Token(dns.tokenizer.QUOTED_STRING, '"foo"')) + self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, '"foo"')) def testQuotedString4(self): tok = dns.tokenizer.Tokenizer(r'"foo\010bar"') token = tok.get() - self.failUnless(token == Token(dns.tokenizer.QUOTED_STRING, 'foo\x0abar')) + self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, 'foo\x0abar')) def testQuotedString5(self): def bad(): tok = dns.tokenizer.Tokenizer(r'"foo') token = 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') token = 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"') token = tok.get() - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def testEmpty1(self): tok = dns.tokenizer.Tokenizer('') token = tok.get() - self.failUnless(token.is_eof()) + self.assertTrue(token.is_eof()) def testEmpty2(self): tok = dns.tokenizer.Tokenizer('') token1 = tok.get() token2 = tok.get() - self.failUnless(token1.is_eof() and token2.is_eof()) + self.assertTrue(token1.is_eof() and token2.is_eof()) def testEOL(self): tok = dns.tokenizer.Tokenizer('\n') token1 = tok.get() token2 = tok.get() - self.failUnless(token1.is_eol() and token2.is_eof()) + self.assertTrue(token1.is_eol() and token2.is_eof()) def testWS1(self): tok = dns.tokenizer.Tokenizer(' \n') token1 = tok.get() - self.failUnless(token1.is_eol()) + self.assertTrue(token1.is_eol()) def testWS2(self): tok = dns.tokenizer.Tokenizer(' \n') token1 = tok.get(want_leading=True) - self.failUnless(token1.is_whitespace()) + self.assertTrue(token1.is_whitespace()) def testComment1(self): tok = dns.tokenizer.Tokenizer(' ;foo\n') token1 = tok.get() - self.failUnless(token1.is_eol()) + self.assertTrue(token1.is_eol()) def testComment2(self): tok = dns.tokenizer.Tokenizer(' ;foo\n') token1 = tok.get(want_comment = True) token2 = tok.get() - self.failUnless(token1 == Token(dns.tokenizer.COMMENT, 'foo') and + self.assertTrue(token1 == Token(dns.tokenizer.COMMENT, 'foo') and token2.is_eol()) def testComment3(self): tok = dns.tokenizer.Tokenizer(' ;foo bar\n') token1 = tok.get(want_comment = True) token2 = tok.get() - self.failUnless(token1 == Token(dns.tokenizer.COMMENT, 'foo bar') and + self.assertTrue(token1 == Token(dns.tokenizer.COMMENT, 'foo bar') and token2.is_eol()) def testMultiline1(self): tok = dns.tokenizer.Tokenizer('( foo\n\n bar\n)') tokens = list(iter(tok)) - self.failUnless(tokens == [Token(dns.tokenizer.IDENTIFIER, 'foo'), + self.assertTrue(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.failUnless(tokens == [Token(dns.tokenizer.IDENTIFIER, 'foo'), + self.assertTrue(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)') tokens = 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)') tokens = list(iter(tok)) - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) def testUnget1(self): tok = dns.tokenizer.Tokenizer('foo') t1 = tok.get() tok.unget(t1) t2 = tok.get() - self.failUnless(t1 == t2 and t1.ttype == dns.tokenizer.IDENTIFIER and \ + self.assertTrue(t1 == t2 and t1.ttype == dns.tokenizer.IDENTIFIER and \ t1.value == 'foo') def testUnget2(self): @@ -144,47 +144,47 @@ 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') t = tok.get_eol() - self.failUnless(t == '\n') + self.assertTrue(t == '\n') def testGetEOL2(self): tok = dns.tokenizer.Tokenizer('') t = tok.get_eol() - self.failUnless(t == '') + self.assertTrue(t == '') def testEscapedDelimiter1(self): tok = dns.tokenizer.Tokenizer(r'ch\ ld') t = tok.get() - self.failUnless(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\ ld') + self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\ ld') def testEscapedDelimiter2(self): tok = dns.tokenizer.Tokenizer(r'ch\032ld') t = tok.get() - self.failUnless(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\032ld') + self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\032ld') def testEscapedDelimiter3(self): tok = dns.tokenizer.Tokenizer(r'ch\ild') t = tok.get() - self.failUnless(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\ild') + self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\ild') def testEscapedDelimiter1u(self): tok = dns.tokenizer.Tokenizer(r'ch\ ld') t = tok.get().unescape() - self.failUnless(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch ld') + self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch ld') def testEscapedDelimiter2u(self): tok = dns.tokenizer.Tokenizer(r'ch\032ld') t = tok.get().unescape() - self.failUnless(t.ttype == dns.tokenizer.IDENTIFIER and t.value == 'ch ld') + self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == 'ch ld') def testEscapedDelimiter3u(self): tok = dns.tokenizer.Tokenizer(r'ch\ild') t = tok.get().unescape() - self.failUnless(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'child') + self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'child') if __name__ == '__main__': unittest.main() diff --git a/tests/update.py b/tests/update.py index e7254547..915d858e 100644 --- a/tests/update.py +++ b/tests/update.py @@ -72,7 +72,7 @@ class UpdateTestCase(unittest.TestCase): update.delete('bar', 'a', '10.0.0.4') update.delete('blaz','a') update.delete('blaz2') - self.failUnless(update.to_wire() == goodwire) + self.assertTrue(update.to_wire() == goodwire) def test_to_wire2(self): update = dns.update.Update('example') @@ -87,7 +87,7 @@ class UpdateTestCase(unittest.TestCase): update.delete('bar', 'a', '10.0.0.4') update.delete('blaz','a') update.delete('blaz2') - self.failUnless(update.to_wire() == goodwire) + self.assertTrue(update.to_wire() == goodwire) def test_to_wire3(self): update = dns.update.Update('example') @@ -102,13 +102,13 @@ class UpdateTestCase(unittest.TestCase): update.delete('bar', 'a', '10.0.0.4') update.delete('blaz','a') update.delete('blaz2') - self.failUnless(update.to_wire() == goodwire) + self.assertTrue(update.to_wire() == goodwire) def test_from_text1(self): update = dns.message.from_text(update_text) w = update.to_wire(origin=dns.name.from_text('example'), want_shuffle=False) - self.failUnless(w == goodwire) + self.assertTrue(w == goodwire) if __name__ == '__main__': unittest.main() diff --git a/tests/zone.py b/tests/zone.py index c34164aa..59045df9 100644 --- a/tests/zone.py +++ b/tests/zone.py @@ -108,7 +108,7 @@ class ZoneTestCase(unittest.TestCase): finally: if not _keep_output: os.unlink('example1.out') - self.failUnless(ok) + self.assertTrue(ok) def testFromFile2(self): z = dns.zone.from_file('example', 'example', relativize=False) @@ -119,7 +119,7 @@ class ZoneTestCase(unittest.TestCase): finally: if not _keep_output: os.unlink('example2.out') - self.failUnless(ok) + self.assertTrue(ok) def testFromText(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) @@ -127,7 +127,7 @@ class ZoneTestCase(unittest.TestCase): names = sorted(z.nodes.keys()) for n in names: print(z[n].to_text(n), file=f) - self.failUnless(f.getvalue() == example_text_output) + self.assertTrue(f.getvalue() == example_text_output) def testTorture1(self): # @@ -148,155 +148,155 @@ class ZoneTestCase(unittest.TestCase): rd2 = dns.rdata.from_wire(rds.rdclass, rds.rdtype, wire, 0, len(wire), origin = o) - self.failUnless(rd == rd2) + self.assertTrue(rd == rd2) def testEqual(self): z1 = dns.zone.from_text(example_text, 'example.', relativize=True) z2 = dns.zone.from_text(example_text_output, 'example.', relativize=True) - self.failUnless(z1 == z2) + self.assertTrue(z1 == z2) def testNotEqual1(self): z1 = dns.zone.from_text(example_text, 'example.', relativize=True) z2 = dns.zone.from_text(something_quite_similar, 'example.', relativize=True) - self.failUnless(z1 != z2) + self.assertTrue(z1 != z2) def testNotEqual2(self): z1 = dns.zone.from_text(example_text, 'example.', relativize=True) z2 = dns.zone.from_text(something_different, 'example.', relativize=True) - self.failUnless(z1 != z2) + self.assertTrue(z1 != z2) def testNotEqual3(self): z1 = dns.zone.from_text(example_text, 'example.', relativize=True) z2 = dns.zone.from_text(something_different, 'example2.', relativize=True) - self.failUnless(z1 != z2) + self.assertTrue(z1 != z2) def testFindRdataset1(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) rds = z.find_rdataset('@', 'soa') exrds = dns.rdataset.from_text('IN', 'SOA', 300, 'foo bar 1 2 3 4 5') - self.failUnless(rds == exrds) + self.assertTrue(rds == exrds) def testFindRdataset2(self): def bad(): z = dns.zone.from_text(example_text, 'example.', relativize=True) rds = z.find_rdataset('@', 'loc') - self.failUnlessRaises(KeyError, bad) + self.assertRaises(KeyError, bad) def testFindRRset1(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) rrs = z.find_rrset('@', 'soa') exrrs = dns.rrset.from_text('@', 300, 'IN', 'SOA', 'foo bar 1 2 3 4 5') - self.failUnless(rrs == exrrs) + self.assertTrue(rrs == exrrs) def testFindRRset2(self): def bad(): z = dns.zone.from_text(example_text, 'example.', relativize=True) rrs = z.find_rrset('@', 'loc') - self.failUnlessRaises(KeyError, bad) + self.assertRaises(KeyError, bad) def testGetRdataset1(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) rds = z.get_rdataset('@', 'soa') exrds = dns.rdataset.from_text('IN', 'SOA', 300, 'foo bar 1 2 3 4 5') - self.failUnless(rds == exrds) + self.assertTrue(rds == exrds) def testGetRdataset2(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) rds = z.get_rdataset('@', 'loc') - self.failUnless(rds == None) + self.assertTrue(rds == 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.failUnless(rrs == exrrs) + self.assertTrue(rrs == exrrs) def testGetRRset2(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) rrs = z.get_rrset('@', 'loc') - self.failUnless(rrs == None) + self.assertTrue(rrs == 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.failUnless(rds is rdataset) + self.assertTrue(rds is rdataset) def testReplaceRdataset2(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) rdataset = dns.rdataset.from_text('in', 'txt', 300, '"foo"') z.replace_rdataset('@', rdataset) rds = z.get_rdataset('@', 'txt') - self.failUnless(rds is rdataset) + self.assertTrue(rds is rdataset) def testDeleteRdataset1(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) z.delete_rdataset('@', 'ns') rds = z.get_rdataset('@', 'ns') - self.failUnless(rds is None) + self.assertTrue(rds is None) def testDeleteRdataset2(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) z.delete_rdataset('ns1', 'a') node = z.get_node('ns1') - self.failUnless(node is None) + self.assertTrue(node is 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.failUnless(rds == exrds) + self.assertTrue(rds == exrds) def testNodeFindRdataset2(self): def bad(): z = dns.zone.from_text(example_text, 'example.', relativize=True) node = z['@'] rds = node.find_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC) - self.failUnlessRaises(KeyError, bad) + self.assertRaises(KeyError, bad) 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.failUnless(rds == exrds) + self.assertTrue(rds == exrds) 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.failUnless(rds == None) + self.assertTrue(rds == None) def testNodeDeleteRdataset1(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) node = z['@'] rds = node.delete_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA) rds = node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA) - self.failUnless(rds == None) + self.assertTrue(rds == None) def testNodeDeleteRdataset2(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) node = z['@'] rds = node.delete_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC) rds = node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC) - self.failUnless(rds == None) + self.assertTrue(rds == None) def testIterateRdatasets(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) ns = sorted([n for n, r in z.iterate_rdatasets('A')]) - self.failUnless(ns == [dns.name.from_text('ns1', None), + self.assertTrue(ns == [dns.name.from_text('ns1', None), dns.name.from_text('ns2', None)]) def testIterateAllRdatasets(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) ns = sorted([n for n, r in z.iterate_rdatasets()]) - self.failUnless(ns == [dns.name.from_text('@', None), + 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), @@ -313,7 +313,7 @@ class ZoneTestCase(unittest.TestCase): 3600, dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, '10.0.0.2'))] - self.failUnless(l == exl) + self.assertTrue(l == exl) def testIterateAllRdatas(self): z = dns.zone.from_text(example_text, 'example.', relativize=True) @@ -342,43 +342,43 @@ class ZoneTestCase(unittest.TestCase): 3600, dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, '10.0.0.2'))] - self.failUnless(l == exl) + self.assertTrue(l == exl) def testTTLs(self): z = dns.zone.from_text(ttl_example_text, 'example.', relativize=True) n = z['@'] rds = n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA) - self.failUnless(rds.ttl == 3600) + self.assertTrue(rds.ttl == 3600) n = z['ns1'] rds = n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A) - self.failUnless(rds.ttl == 86401) + self.assertTrue(rds.ttl == 86401) n = z['ns2'] rds = n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A) - self.failUnless(rds.ttl == 694861) + self.assertTrue(rds.ttl == 694861) def testNoSOA(self): def bad(): z = 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): def bad(): z = 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): z1 = dns.zone.from_text(include_text, 'example.', relativize=True, allow_include=True) z2 = dns.zone.from_file('example', 'example.', relativize=True) - self.failUnless(z1 == z2) + self.assertTrue(z1 == z2) def testBadDirective(self): def bad(): z = dns.zone.from_text(bad_directive_text, 'example.', relativize=True) - self.failUnlessRaises(dns.exception.SyntaxError, bad) + self.assertRaises(dns.exception.SyntaxError, bad) if __name__ == '__main__': unittest.main()