dnsruby 1.1

data/test/tc_resolver.rb

@@ -0,0 +1,184 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'dnsruby'
+require 'socket'
+require 'test/unit'
+include Dnsruby
+#@TODO@ We also need a test server so we can control behaviour of server to test
+#different aspects of retry strategy.
+#Of course, with Ruby's limit of 256 open sockets per process, we'd need to run 
+#the server in a different Ruby process.
+
+class TestResolver < Test::Unit::TestCase
+  include Dnsruby
+  Thread::abort_on_exception = true
+  PORT = 42138
+  @@port = PORT
+  def setup
+    Dnsruby::Config.reset
+  end
+  
+  def test_send_message
+    res = Resolver.new
+    ret = res.send_message(Message.new("example.com", Types.A))
+    assert(ret.kind_of?(Message))
+  end
+  
+  def test_query
+    res = Resolver.new
+    ret = res.query("example.com")
+    assert(ret.kind_of?(Message))
+  end
+  
+  def test_query_async
+    res = Resolver.new
+    q = Queue.new
+    res.send_async(Message.new("example.com", Types.A),q,q)
+    id, ret, error = q.pop
+    assert_equal(id, q, "Id wrong!")
+    assert(ret.kind_of?(Message), "Ret wrong!")
+    assert(error==nil)
+  end
+  
+  def test_query_one_duff_server_one_good
+    res = Resolver.new({:nameserver => ["localhost", "128.8.10.90"]})
+    res.retry_delay=1
+    q = Queue.new
+    res.send_async(Message.new("example.com", Types.A),q,q)
+    id, ret, error = q.pop
+    assert_equal(id, q, "Id wrong!")
+    assert(ret.kind_of?(Message), "Ret wrong! (#{ret.class}")
+    assert(error==nil)
+  end
+
+  # @TODO@ Implement!!  But then, why would anyone want to do this?
+  #  def test_many_threaded_clients
+  #    assert(false, "IMPLEMENT!")
+  #  end
+  
+  def test_reverse_lookup
+    m = Message.new("210.251.121.214", Types.PTR)
+    r = Resolver.new
+    q=Queue.new
+    r.send_async(m,q,q)
+    id,ret, error=q.pop
+    assert(ret.kind_of?(Message))
+    no_pointer=true
+    ret.each_answer do |answer|
+      if (answer.type==Types.PTR)
+        no_pointer=false
+        assert(answer.domainname.to_s=~/ruby-lang/)      
+      end
+    end
+    assert(!no_pointer)
+  end
+  
+  def test_bad_host
+    res = Resolver.new({:nameserver => "localhost"})
+    res.retry_times=1
+    res.retry_delay=0
+    res.query_timeout = 1
+    q = Queue.new
+    res.send_async(Message.new("example.com", Types.A), q, q)
+    id, m, err = q.pop
+    assert(id==q)
+    assert(m == nil)
+    assert(err.kind_of?(OtherResolvError) || err.kind_of?(IOError), "OtherResolvError or IOError expected : got #{err.class}")
+  end
+  
+  def test_nxdomain
+    res=Resolver.new
+    q = Queue.new
+    res.send_async(Message.new("dklfjhdFHFHDVVUIEWRFDSAJKVCNASDLFJHN.com", Types.A), q, 1)
+    id, m, err = q.pop
+    assert(id==1)
+    assert(m.header.rcode == RCode.NXDOMAIN)
+    assert(err.kind_of?(NXDomain))
+  end
+  
+  def test_timeouts
+    #test timeout behaviour for different retry, retrans, total timeout etc.
+    #Problem here is that many sockets will be created for queries which time out. 
+    # Run a query which will not respond, and check that the timeout works
+    if (!RUBY_PLATFORM=~/darwin/)
+      start=stop=0
+      retry_times = 3
+      retry_delay=1
+      packet_timeout=2
+      # Work out what time should be, then time it to check
+      expected = ((2**(retry_times-1))*retry_delay) + packet_timeout
+      begin
+        res = Resolver.new({:nameserver => "10.0.1.128"})
+        #      res = Resolver.new({:nameserver => "213.248.199.17"})
+        res.packet_timeout=packet_timeout
+        res.retry_times=retry_times
+        res.retry_delay=retry_delay
+        start=Time.now
+        m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
+        fail
+      rescue ResolvTimeout
+        stop=Time.now
+        time = stop-start
+        assert(time <= expected *1.2 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")        
+      end
+  end
+  end
+  
+  def test_packet_timeout
+    if (!RUBY_PLATFORM=~/darwin/)
+      res = Resolver.new({:nameserver => "10.0.1.128"})
+      start=stop=0
+      retry_times = retry_delay = packet_timeout= 10
+      query_timeout=1
+      begin
+        res.packet_timeout=packet_timeout
+        res.retry_times=retry_times
+        res.retry_delay=retry_delay
+        res.query_timeout=query_timeout
+        # Work out what time should be, then time it to check
+        expected = query_timeout
+        start=Time.now
+        m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
+        fail
+      rescue ResolvTimeout
+        stop=Time.now
+        time = stop-start
+        assert(time <= expected *1.1 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")        
+      end    #
+  end
+  end
+  
+  def test_queue_packet_timeout
+    if (!RUBY_PLATFORM=~/darwin/)
+      res = Resolver.new({:nameserver => "10.0.1.128"})
+      bad = SingleResolver.new("localhost")
+      res.add_resolver(bad)
+      expected = 1
+      res.query_timeout=expected    
+      q = Queue.new
+      start = Time.now
+      m = res.send_async(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A), q, q)
+      id,ret,err = q.pop
+      stop = Time.now
+      assert(id=q)
+      assert(ret==nil)
+      assert(err.class == ResolvTimeout, "#{err.class}, #{err}")
+      time = stop-start
+      assert(time <= expected *1.2 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")            
+    end
+  end
+  
+end

data/test/tc_rr-opt.rb

@@ -0,0 +1,82 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+require 'socket'
+include Dnsruby
+class TestRrOpt < Test::Unit::TestCase
+  def test_rropt
+    size=2048;
+    ednsflags=0x9e22;
+    
+    optrr = RR::OPT.new(size, ednsflags)
+    
+    assert(optrr.dnssec_ok,"DO bit set")
+    optrr.dnssec_ok=false
+    assert_equal(optrr.flags,0x1e22,"Clearing do, leaving the other bits ");
+    assert(!optrr.dnssec_ok,"DO bit cleared")
+    optrr.dnssec_ok=true
+    assert_equal(optrr.flags,0x9e22,"Clearing do, leaving the other bits ");
+    
+    
+    assert_equal(optrr.payloadsize,2048,"Size read")
+    assert_equal(optrr.payloadsize=(1498),1498,"Size set")
+    
+  end
+  
+  def test_resolver_opt_application
+        return if (/java/ =~ RUBY_PLATFORM) # @TODO@ Check if this is fixed with JRuby yet
+    # Set up a server running on localhost. Get the resolver to send a
+    # query to it with the UDP size set to 4096. Make sure that it is received
+    # correctly.
+    socket = UDPSocket.new
+    socket.bind("127.0.0.1", 0)
+    port = socket.addr[1]
+    q = Queue.new
+    Thread.new {
+      s = socket.recvfrom(65536)
+      print s.length
+      received_query = s[0]
+      socket.connect(s[1][2], s[1][1])
+      q.push(Message.decode(received_query))
+      socket.send(received_query,0)
+    }
+    
+    # Now send query
+    res = Resolver.new("127.0.0.1")
+    res.port = port
+    res.udp_size = 4096
+    assert(res.udp_size == 4096)
+    res.query("example.com")
+    
+    # Now get received query from the server
+    p = q.pop
+    # Now check the query was what we expected
+    assert(p.header.arcount == 1)
+    assert(p.additional()[0].type = Types.OPT)
+    assert(p.additional()[0].klass.code == 4096)
+  end
+  
+  def test_large_packet
+    # Query TXT for overflow.dnsruby.validation-test-servers.nominet.org.uk
+    # with a large udp_size
+    res = SingleResolver.new
+    res.udp_size = 4096
+    ret = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", Types.TXT)
+    assert(ret.header.rcode == RCode.NoError)
+  end
+end

data/test/tc_rr-txt.rb

@@ -0,0 +1,137 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+include Dnsruby
+class TestRrTest < Test::Unit::TestCase
+  #Stimulus, expected response, and test name:
+  
+  TESTLIST =	[
+  {	# 2-5
+    :stim		=>	%<"">,
+    :rdatastr	=>	%<"">,
+    :char_str_list_r	=>	['',],
+    :descr		=>	'Double-quoted null string',
+  },
+  {	# 6-9
+    :stim		=>	%<''>,
+    :rdatastr	=>	%<"">,
+    :char_str_list_r	=>	['',],
+    :descr		=>	'Single-quoted null string',
+  },
+  {	# 10-13
+    :stim		=>	%<" \t">,
+    :rdatastr	=>	%<" \t">,
+    :char_str_list_r	=>	[ %< \t>, ],
+    :descr		=>	'Double-quoted whitespace string',
+  },
+  {	# 14-17
+    :stim		=>	%<noquotes>,
+    :rdatastr	=>	%<"noquotes">,
+    :char_str_list_r	=>	[ %<noquotes>, ],
+    :descr		=>	'unquoted single string',
+  },
+  {	# 18-21
+    :stim		=>	%<"yes_quotes">,
+    :rdatastr	=>	%<"yes_quotes">,
+    :char_str_list_r	=>	[ %<yes_quotes>, ],
+    :descr		=>	'Double-quoted single string',
+  },
+  {	# 26-29
+    :stim		=>	%<two tokens>,
+    :rdatastr	=>	%<"two" "tokens">,
+    :char_str_list_r	=>	[ %q|two|, %q|tokens|, ],
+    :descr		=>	'Two unquoted strings',
+  },
+  # @TODO@ Why don't escaped quotes work?
+  #    {	# 22-25
+  #			:stim		=>	%<"escaped \" quote">,
+  #			:rdatastr	=>	%<"escaped \" quote">,
+  #			:char_str_list_r	=>	[ %<escaped " quote>, ],
+  #			:descr		=>	'Quoted, escaped double-quote',
+  #    },
+  #    { # 30-33
+  #			:stim		=> %<"missing quote>,
+  #			:rdatastr    => %<>,
+  #			:char_str_list_r	=>	[],
+  #			:descr    	=> 'Unbalanced quotes work',
+  #    }
+  ]
+  
+  def test_RrTest
+    #------------------------------------------------------------------------------
+    # Canned data.
+    #------------------------------------------------------------------------------
+    
+    name			= 'foo.example.com';
+    klass			= 'IN';
+    type			= 'TXT';
+    ttl				= 43201;
+    
+    rr_base	= [name, ttl, klass, type, "    " ].join(' ')
+    
+    
+    #------------------------------------------------------------------------------
+    # Run the tests
+    #------------------------------------------------------------------------------
+    
+    TESTLIST.each do |test_hr|
+      assert( uut = RR.create(rr_base + test_hr[:stim]), 	
+      test_hr[:descr] + " -- Stimulus " ) 
+            
+      assert_equal(test_hr[:rdatastr], uut.rdata_to_string(), 			
+      test_hr[:descr] + " -- Response ( rdatastr ) " ) 
+      
+      list = uut.strings	
+      
+      assert_equal(test_hr[:char_str_list_r], list,
+                   test_hr[:descr] +  " -- char_str_list equality"  ) 		
+    end
+    
+    string1 = %<no>
+    string2 = %<quotes>
+    
+    rdata = [string1.length].pack("C") + string1
+    rdata += [string2.length].pack("C") + string2
+    
+    work_hash = {
+      :name		=> name,
+      :ttl		=> ttl,
+      :class		=> klass,
+      :type		=> type,
+    }
+    
+    
+    # Don't break RR.new_from_hash (e.i. "See the manual pages for each RR 
+    # type to see what fields the type requires.").
+    
+    work_hash[:strings] = %<no quotes>
+    
+    uut = RR.create(work_hash)    
+    assert( uut , 		# 30
+    "RR.new_from_hash with txtdata -- Stimulus")
+    assert_equal( uut.rdata_to_string() , %<"no" "quotes">, 		# 31
+    "RR.new_from_hash with txtdata -- Response (rdatastr())")
+    
+    rr_rdata = MessageEncoder.new {|msg|
+      uut.encode_rdata(msg)
+    }.to_s
+    assert( rr_rdata == rdata , "TXT.rr_rdata" )	# 32
+    
+    
+  end
+end

data/test/tc_rr-unknown.rb

@@ -0,0 +1,99 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+class TestRrUnknown < Test::Unit::TestCase
+  def test_RrUnknown
+    assert_equal(10226, Types::typesbyname('TYPE10226'), 'typesbyname(TYPE10226) returns 10226')
+    assert_equal('TYPE10226', Types::typesbyval(10226),        'typesbyval(10226) returns TYPE10226')
+    assert_equal(Types::typesbyval(1), "A",           '       typesbyval(1) returns A')
+    
+    assert_equal(Types::typesbyval(Types.typesbyname('TYPE001')), 'A', 'typesbyval(typebyname(TYPE001)) returns A')
+    
+    
+    begin
+      Types.typesbyval(0xffff+1)
+      flunk("Should fail on large TYPE code")
+    rescue Exception
+    end
+    
+    assert_equal(Classes::classesbyname('CLASS124'), 124,       'classesbyname(CLASS124) returns 124')
+    assert_equal(Classes::classesbyval(125),         'CLASS125','classesbyval(125) returns CLASS125')
+    assert_equal(Classes::classesbyval(1),           'IN',      'classesbyval(1) returns IN')
+    
+    assert_equal('HS', Classes::classesbyval(Classes::classesbyname('CLASS04')), 'classesbyval(typebyname(CLASS04)) returns HS')
+    
+    begin
+      Classes::classesbyval(0xffff+1)
+      flunk("Should fail on large CLASS code")
+    rescue Exception
+    end
+  end
+  
+  def test_rr_new
+    rr = RR.new_from_string('e.example CLASS01 TYPE01 10.0.0.2')
+    assert_equal(RR::IN::A, rr.class,  'TYPE01 parsed OK')
+    assert_equal('A', rr.type.string,  'TYPE01 parsed OK')
+    assert_equal('IN', rr.klass.string,'CLASS01 parsed OK')
+    assert_equal(1, rr.klass.code,'CLASS01 parsed OK')
+    
+    rr = RR.new_from_string('e.example IN A \# 4  0A0000 01  ')
+    assert_equal('10.0.0.1', rr.address.to_s,'Unknown RR representation for A parsed OK')
+    
+    begin
+      res=RR.new_from_string('e.example IN A \# 4  0A0000 01 11 ')
+      flunk "Should fail on inconsistent length and hex presentation"
+    rescue Exception
+      #like($@, '/\\\# 4  0A0000 01 11 assert_equal inconsistent\ length does not match content/', 'Fails on inconsassert_equaltent length and hex presentation')
+    end
+    
+    
+    rr = RR.new_from_string('e.example IN TYPE4555 \# 4  0A0000 01  ')
+    assert_equal('e.example.	0	IN	TYPE4555	\# 4 0a000001', rr.to_s, 'Fully unknown RR parsed correctly')
+    
+    rr4 = RR.new_from_string('e.example CLASS122 TYPE4555 \# 4  0A0000 01  ')
+    assert_equal('e.example.	0	CLASS122	TYPE4555	\# 4 0a000001', rr4.to_s, 'Fully unknown RR in unknown CLASS parsed correctly')
+  end
+  
+  def test_real_data
+    uuencodedPacket=%w{
+02 79 85 00 00 01 
+00 01 00 01 00 01 04 54  45 53 54 07 65 78 61 6d 
+70 6c 65 03 63 6f 6d 00  00 ff 00 01 c0 0c 30 39 
+00 01 00 00 00 7b 00 0a  11 22 33 44 55 aa bb cc 
+dd ee c0 11 00 02 00 01  00 00 03 84 00 05 02 6e 
+73 c0 11 c0 44 00 01 00  01 00 00 03 84 00 04 7f 
+00 00 01}
+    
+    #    packetdata = uuencodedPacket.pack('H*')
+    #    packetdata = packetdata.gsub("\s*", "")
+    
+    uuencodedPacket.map!{|e| e.hex}
+    packetdata = uuencodedPacket.pack('c*')
+#    packet     = Net::Packet.new_from_binary(packetdata)
+    packet = Message.decode(packetdata)
+    
+    string_representation = (packet.answer)[0].to_s
+    #string_representation =~ s/\s+/ /g,
+    string_representation = string_representation.gsub(/\s+/, " ")
+    assert_equal(
+	'TEST.example.com. 123 IN TYPE12345 \# 10 1122334455aabbccddee',
+    string_representation,
+	'Packet read from a packet dumped by bind...'
+    )
+  end
+end