lib/dnspython/tests/message.py

   1 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
   2 #
   3 # Permission to use, copy, modify, and distribute this software and its
   4 # documentation for any purpose with or without fee is hereby granted,
   5 # provided that the above copyright notice and this permission notice
   6 # appear in all copies.
   7 #
   8 # THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
   9 # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10 # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
  11 # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12 # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  14 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15
  16 import cStringIO
  17 import os
  18 import unittest
  19
  20 import dns.exception
  21 import dns.message
  22
  23 query_text = """id 1234
  24 opcode QUERY
  25 rcode NOERROR
  26 flags RD
  27 edns 0
  28 eflags DO
  29 payload 4096
  30 ;QUESTION
  31 wwww.dnspython.org. IN A
  32 ;ANSWER
  33 ;AUTHORITY
  34 ;ADDITIONAL"""
  35
  36 goodhex = '04d201000001000000000001047777777709646e73707974686f6e' \
  37           '036f726700000100010000291000000080000000'
  38
  39 goodwire = goodhex.decode('hex_codec')
  40
  41 answer_text = """id 1234
  42 opcode QUERY
  43 rcode NOERROR
  44 flags QR AA RD
  45 ;QUESTION
  46 dnspython.org. IN SOA
  47 ;ANSWER
  48 dnspython.org. 3600 IN SOA woof.dnspython.org. hostmaster.dnspython.org. 2003052700 3600 1800 604800 3600
  49 ;AUTHORITY
  50 dnspython.org. 3600 IN NS ns1.staff.nominum.org.
  51 dnspython.org. 3600 IN NS ns2.staff.nominum.org.
  52 dnspython.org. 3600 IN NS woof.play-bow.org.
  53 ;ADDITIONAL
  54 woof.play-bow.org. 3600 IN A 204.152.186.150
  55 """
  56
  57 goodhex2 = '04d2 8500 0001 0001 0003 0001' \
  58            '09646e73707974686f6e036f726700 0006 0001' \
  59            'c00c 0006 0001 00000e10 0028 ' \
  60                '04776f6f66c00c 0a686f73746d6173746572c00c' \
  61                '7764289c 00000e10 00000708 00093a80 00000e10' \
  62            'c00c 0002 0001 00000e10 0014' \
  63                '036e7331057374616666076e6f6d696e756dc016' \
  64            'c00c 0002 0001 00000e10 0006 036e7332c063' \
  65            'c00c 0002 0001 00000e10 0010 04776f6f6608706c61792d626f77c016' \
  66            'c091 0001 0001 00000e10 0004 cc98ba96'
  67
  68
  69 goodwire2 = goodhex2.replace(' ', '').decode('hex_codec')
  70
  71 query_text_2 = """id 1234
  72 opcode QUERY
  73 rcode 4095
  74 flags RD
  75 edns 0
  76 eflags DO
  77 payload 4096
  78 ;QUESTION
  79 wwww.dnspython.org. IN A
  80 ;ANSWER
  81 ;AUTHORITY
  82 ;ADDITIONAL"""
  83
  84 goodhex3 = '04d2010f0001000000000001047777777709646e73707974686f6e' \
  85           '036f726700000100010000291000ff0080000000'
  86
  87 goodwire3 = goodhex3.decode('hex_codec')
  88
  89 class MessageTestCase(unittest.TestCase):
  90
  91     def test_comparison_eq1(self):
  92         q1 = dns.message.from_text(query_text)
  93         q2 = dns.message.from_text(query_text)
  94         self.failUnless(q1 == q2)
  95
  96     def test_comparison_ne1(self):
  97         q1 = dns.message.from_text(query_text)
  98         q2 = dns.message.from_text(query_text)
  99         q2.id = 10
 100         self.failUnless(q1 != q2)
 101
 102     def test_comparison_ne2(self):
 103         q1 = dns.message.from_text(query_text)
 104         q2 = dns.message.from_text(query_text)
 105         q2.question = []
 106         self.failUnless(q1 != q2)
 107
 108     def test_comparison_ne3(self):
 109         q1 = dns.message.from_text(query_text)
 110         self.failUnless(q1 != 1)
 111
 112     def test_EDNS_to_wire1(self):
 113         q = dns.message.from_text(query_text)
 114         w = q.to_wire()
 115         self.failUnless(w == goodwire)
 116
 117     def test_EDNS_from_wire1(self):
 118         m = dns.message.from_wire(goodwire)
 119         self.failUnless(str(m) == query_text)
 120
 121     def test_EDNS_to_wire2(self):
 122         q = dns.message.from_text(query_text_2)
 123         w = q.to_wire()
 124         self.failUnless(w == goodwire3)
 125
 126     def test_EDNS_from_wire2(self):
 127         m = dns.message.from_wire(goodwire3)
 128         self.failUnless(str(m) == query_text_2)
 129
 130     def test_TooBig(self):
 131         def bad():
 132             q = dns.message.from_text(query_text)
 133             for i in xrange(0, 25):
 134                 rrset = dns.rrset.from_text('foo%d.' % i, 3600,
 135                                             dns.rdataclass.IN,
 136                                             dns.rdatatype.A,
 137                                             '10.0.0.%d' % i)
 138                 q.additional.append(rrset)
 139             w = q.to_wire(max_size=512)
 140         self.failUnlessRaises(dns.exception.TooBig, bad)
 141
 142     def test_answer1(self):
 143         a = dns.message.from_text(answer_text)
 144         wire = a.to_wire(want_shuffle=False)
 145         self.failUnless(wire == goodwire2)
 146
 147     def test_TrailingJunk(self):
 148         def bad():
 149             badwire = goodwire + '\x00'
 150             m = dns.message.from_wire(badwire)
 151         self.failUnlessRaises(dns.message.TrailingJunk, bad)
 152
 153     def test_ShortHeader(self):
 154         def bad():
 155             badwire = '\x00' * 11
 156             m = dns.message.from_wire(badwire)
 157         self.failUnlessRaises(dns.message.ShortHeader, bad)
 158
 159     def test_RespondingToResponse(self):
 160         def bad():
 161             q = dns.message.make_query('foo', 'A')
 162             r1 = dns.message.make_response(q)
 163             r2 = dns.message.make_response(r1)
 164         self.failUnlessRaises(dns.exception.FormError, bad)
 165
 166     def test_ExtendedRcodeSetting(self):
 167         m = dns.message.make_query('foo', 'A')
 168         m.set_rcode(4095)
 169         self.failUnless(m.rcode() == 4095)
 170         m.set_rcode(2)
 171         self.failUnless(m.rcode() == 2)
 172
 173     def test_EDNSVersionCoherence(self):
 174         m = dns.message.make_query('foo', 'A')
 175         m.use_edns(1)
 176         self.failUnless((m.ednsflags >> 16) & 0xFF == 1)
 177
 178 if __name__ == '__main__':
 179     unittest.main()