+2011-04-05 Bob Halley <halley@dnspython.org>
+
+ * 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 <halley@dnspython.org>
+
+ * (Version 1.9.4 released)
+
+2011-03-24 Bob Halley <halley@dnspython.org>
+
+ * 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 <halley@dnspython.org>
+
+ * (Version 1.9.3 released)
+
+2011-03-22 Bob Halley <halley@dnspython.org>
+
+ * 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 <halley@dnspython.org>
+
+ * 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 <halley@dnspython.org>
+
+ * 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 <halley@dnspython.org>
* dns/resolver.py (Resolver.query): disallow metaqueries.
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:
REQUIREMENTS
-Python 3.1 or later.
+Python 2.4 or later.
INSTALLATION
'update',
'util',
'version',
+ 'wiredata',
'zone',
]
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."""
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
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:
import dns.exception
import dns.util
+import dns.wiredata
NAMERELN_NONE = 0
NAMERELN_SUPERDOMAIN = 1
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
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
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()
import dns.rdataclass
import dns.rdatatype
import dns.tokenizer
+import dns.wiredata
import dns.util
_hex_chunksize = 32
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.
@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)
@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']
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)
# 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
"""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"""
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 = []
"""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']
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:
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)
+++ /dev/null
-# 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
@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']
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))
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)
@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']
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 = []
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))
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)
@ivar iterations: the number of iterations
@type iterations: int
@ivar salt: the salt
- @type salt: string"""
+ @type salt: bytes"""
__slots__ = ['algorithm', 'flags', 'iterations', 'salt']
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:
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)
+++ /dev/null
-# 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
# 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
+++ /dev/null
-# 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
@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']
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)
'HINFO',
'HIP',
'ISDN',
- 'KEY',
'LOC',
'MX',
'NS',
'NSEC',
'NSEC3',
'NSEC3PARAM',
- 'NXT',
'PTR',
'RP',
'RRSIG',
'RT',
- 'SIG',
'SOA',
'SPF',
'SSHFP',
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:
@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']
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)
@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']
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)
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']
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)
@ivar protocol: the protocol
@type protocol: int
@ivar bitmap: the bitmap
- @type bitmap: string
+ @type bitmap: bytes
@see: RFC 1035"""
__slots__ = ['address', 'protocol', 'bitmap']
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)
'IN',
'mxbase',
'nsbase',
- 'sigbase',
- 'keybase',
]
@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']
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):
+++ /dev/null
-# 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
+++ /dev/null
-# 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
@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
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):
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
@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."""
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
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.
MAJOR = 1
MINOR = 9
-MICRO = 3
+MICRO = 5
RELEASELEVEL = 0x0f
SERIAL = 0
--- /dev/null
+# 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
import sys
from distutils.core import setup
-version = '1.9.3'
+version = '1.9.5'
kwargs = {
'name' : 'dnspython',
'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",
"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)
# $Id: Makefile,v 1.5 2004/03/19 00:17:27 halley Exp $
-PYTHON=python3.1
+PYTHON=python3.2
check: test
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()
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,
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,
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
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
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 . .
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
yzWZriO6i2odGWWQVucZqKVsENW91IOW4vqudngPZsY3
GvQ/xVA8/7pyFj6b7Esga60zyGW6LFe9r8n6paHrlG5o
jqf0BaqHT+8= )
-dnskey02 DNSKEY HOST|FLAG4 DNSSEC RSAMD5 (
+dnskey02 DNSKEY 257 3 RSAMD5 (
AQMFD5raczCJHViKtLYhWGz8hMY9UGRuniJDBzC7w0aR
yzWZriO6i2odGWWQVucZqKVsENW91IOW4vqudngPZsY3
GvQ/xVA8/7pyFj6b7Esga60zyGW6LFe9r8n6paHrlG5o
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"
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
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 . .
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.
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"
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
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 . .
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.
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__':
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():
'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()
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 = [
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')
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')
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')
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')
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():
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'
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):
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)
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()
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()
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()
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()
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):
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):
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):
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()
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])
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()
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):
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()
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')
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')
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()
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)
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)
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):
#
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),
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)
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()
projects / thirdparty / dnspython.git / commitdiff
