dnsruby 1.1

data/test/tc_rr.rb

@@ -0,0 +1,258 @@
+#--
+#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 TestRR < Test::Unit::TestCase
+  def test_rr
+    #------------------------------------------------------------------------------
+    # Canned data.
+    #------------------------------------------------------------------------------
+    
+    name			= "foo.example.com";
+    klass			= "IN";
+    ttl				= 43200;
+    
+    rrs = [
+    {  	#[0]
+      :type        => Types.A,
+      :address     => '10.0.0.1',  
+    }, 
+    {	#[1]
+      :type      => Types::AAAA,
+      :address     => '102:304:506:708:90a:b0c:d0e:ff10',
+    }, 
+    {	#[2]
+      :type         => 'AFSDB',
+      :subtype      => 1,
+      :hostname     => 'afsdb-hostname.example.com',
+    }, 
+    {	#[3]
+      :type         => Types.CNAME,
+      :domainname        => 'cname-cname.example.com',
+    }, 
+    {   #[4]
+      :type         => Types.DNAME,
+      :domainname        => 'dname.example.com',
+    },
+    {	#[5]
+      :type         => Types.HINFO,
+      :cpu          => 'test-cpu',
+      :os           => 'test-os',
+    }, 
+    {	#[6]
+      :type         => Types.ISDN,
+      :address      => '987654321',
+      :subaddress           => '001',
+    }, 
+    {	#[7]
+      :type         => Types.MB,
+      :domainname      => 'mb-madname.example.com',
+    }, 
+    {	#[8]
+      :type         => Types.MG,
+      :domainname   => 'mg-mgmname.example.com',
+    }, 
+    {	#[9]
+      :type         => Types.MINFO,
+      :rmailbx      => 'minfo-rmailbx.example.com',
+      :emailbx      => 'minfo-emailbx.example.com',
+    }, 
+    {	#[10]
+      :type         => Types.MR,
+      :domainname      => 'mr-newname.example.com',
+    }, 
+    {	#[11]
+      :type         => Types.MX,
+      :preference   => 10,
+      :exchange     => 'mx-exchange.example.com',
+    },
+    {	#[12]
+      :type        => Types.NAPTR,
+      :order        => 100,
+      :preference   => 10,
+      :flags        => 'naptr-flags',
+      :service      => 'naptr-service',
+      :regexp       => 'naptr-regexp',
+      :replacement  => 'naptr-replacement.example.com',
+    },
+    {	#[13]
+      :type         => Types.NS,
+      :domainname      => 'ns-nsdname.example.com',
+    },
+    {	#[14]
+      :type         => Types.NSAP,
+      :afi          => '47',
+      :idi          => '0005',
+      :dfi          => '80',
+      :aa           => '005a00',
+      :rd           => '1000',
+      :area         => '0020',
+      :id           => '00800a123456',
+      :sel          => '00',
+      #      #:address => '4700580005a001000002000800a12345600'
+      #      :address => '47000580005a0000001000002000800a12345600'
+    },
+    {	#[15]
+      :type         => Types.PTR,
+      :domainname     => 'ptr-ptrdname.example.com',
+    },
+    {	#[16] 
+      :type         => Types.PX,
+      :preference   => 10,
+      :map822       => 'px-map822.example.com',
+      :mapx400      => 'px-mapx400.example.com',
+    },
+    {	#[17]
+      :type         => Types.RP,
+      :mailbox		 => 'rp-mbox.example.com',
+      :txtdomain     => 'rp-txtdname.example.com',
+    },
+    {	#[18]
+      :type         => Types.RT,
+      :preference   => 10,
+      :intermediate => 'rt-intermediate.example.com',
+    },
+    {	#[19]
+      :type         => Types.SOA,
+      :mname        => 'soa-mname.example.com',
+      :rname        => 'soa-rname.example.com',
+      :serial       => 12345,
+      :refresh      => 7200,
+      :retry        => 3600,
+      :expire       => 2592000,
+      :minimum      => 86400,
+    },
+    {	#[20]
+      :type         => Types.SRV,
+      :priority     => 1,
+      :weight       => 2,
+      :port         => 3,
+      :target       => 'srv-target.example.com',
+    },
+    {	#[21]
+      :type         => Types.TXT,
+      :strings => 'txt-txtdata',
+    },
+    {	#[22]
+      :type         => Types.X25,
+      :address      => '123456789',
+    },
+    {	#[23]
+      :type        => Types.LOC,
+      :version      => 0,
+      :size         => 3000,
+      :horiz_pre    => 500000,
+      :vert_pre     => 500,
+      :latitude     => 2001683648,
+      :longitude    => 1856783648,
+      :altitude     => 9997600,
+    }, 	#[24]
+    {
+      :type         => Types.CERT,
+      :certtype   => 3,
+      :keytag			 => 1,
+      :alg    => 1,
+      :cert  => '123456789abcdefghijklmnopqrstuvwxyz',
+    },
+    {	#[25]
+      :type         => Types.SPF,
+      :strings      => 'txt-txtdata',
+    },
+    ]
+    
+    
+    #------------------------------------------------------------------------------
+    # Create the packet
+    #------------------------------------------------------------------------------
+    
+    message = Message.new
+    assert(message,         'Message created');
+    
+    
+    rrs.each do |data|
+      data.update({	   :name => name,
+        :ttl  => ttl,
+      })
+      rr=RR.create(data)
+      
+      message.add_answer(rr);
+    end
+    
+    #------------------------------------------------------------------------------
+    # Re-create the packet from data.
+    #------------------------------------------------------------------------------
+    data = message.encode;
+    assert(data,            'Packet has data after pushes');
+    
+    message=nil;
+    message= Message.decode(data);
+    
+    assert(message,          'Packet reconstructed from data');
+    
+    answer = message.answer;
+    
+    i = 0
+    rrs.each do |rec|
+      ret_rr = answer[i]
+      i += 1
+      rec.each do |key, value|
+        #        method = key+'=?'
+        x = ret_rr.send(key)
+        if (ret_rr.kind_of?RR::CERT and (key == :alg or key == :certtype))
+          assert_equal(value.to_s, x.code.to_s.downcase, "Packet returned wrong answer section for #{ret_rr.to_s}, #{key}")
+        else
+          if (key == :type)
+            assert_equal(Types.new(value).to_s.downcase, x.to_s.downcase, "Packet returned wrong answer section for #{ret_rr.to_s}, #{key}")
+          else
+            assert_equal(value.to_s.downcase, x.to_s.downcase, "Packet returned wrong answer section for #{ret_rr.to_s}, #{key}")
+          end
+        end
+      end
+    end
+    
+    
+    
+    while (!answer.empty? and !rrs.empty?)
+      data = rrs.shift;
+      rr   = answer.shift;
+      type = data[:type];
+      
+      assert(rr,                         "#{type} - RR defined");    
+      assert_equal(name,       	rr.name.to_s,    "#{type} - name() correct");         
+      assert_equal(klass,      	Classes.to_string(rr.class::ClassValue),   "#{type} - class() correct");  
+      assert_equal(ttl,        	rr.ttl,     "#{type} - ttl() correct");                
+      
+      #	foreach my $meth (keys %{data}) {
+      data.keys.each do |meth|
+        ret = rr.send(meth)
+        if (rr.kind_of?RR::CERT and (meth == :alg or meth == :certtype))
+          assert_equal(data[meth].to_s, ret.code.to_s.downcase, "#{type} - #{meth}() correct")
+        else
+          if (meth == :type)
+            assert_equal(Types.new(data[meth]).to_s.downcase, ret.to_s.downcase, "#{type} - #{meth}() correct");
+          else
+            assert_equal(data[meth].to_s, ret.to_s.downcase, "#{type} - #{meth}() correct");
+          end
+        end
+      end
+      
+      rr2 = RR.new_from_string(rr.to_s)
+      assert_equal(rr.to_s,   rr2.to_s, "#{type} - Parsing from string works")
+    end
+  end
+end

data/test/tc_rrset.rb

@@ -0,0 +1,58 @@
+require 'test/unit'
+require 'dnsruby'
+
+class RrsetTest < Test::Unit::TestCase
+  def test_rrset
+    rrset = Dnsruby::RRSet.new
+
+      
+    rr=Dnsruby::RR.create({	   :name => "example.com",
+        :ttl  => 3600,
+        :type         => 'MX',
+        :preference   => 10,
+        :exchange     => 'mx-exchange.example.com',
+      })
+
+    rrset.add(rr)
+    rr.preference = 12
+    rrset.add(rr)
+    rr.preference = 1
+    rrset.add(rr)
+    
+    canon = rrset.sort_canonical
+    
+    assert(1, canon[0].preference)
+    assert(10, canon[1].preference)
+    assert(12, canon[2].preference)
+    
+    assert(rrset.sigs.length == 0)
+    assert(rrset.num_sigs == 0)
+    assert(rrset.rrs.length == 3)
+
+    # Check RRSIG records (only of the right type) can be added to the RRSet
+    sig = Dnsruby::RR.create({:name=>"example.com",         :ttl  => 3600,
+        :type         => 'RRSIG',
+        :type_covered  => 'A',
+        :original_ttl => 3600,
+        :algorithm => Dnsruby::Algorithms::RSASHA1,
+        :labels => 3,
+        :expiration => Time.mktime(2003,03,22,17,31, 03).to_i,
+        :inception => Time.mktime(2003,02,20,17,31,03).to_i,
+        :key_tag => 2642
+      })
+    assert(!rrset.add(sig))
+    assert(rrset.sigs.length == 0)
+    assert(rrset.num_sigs == 0)
+    assert(rrset.rrs.length == 3)
+    sig.type_covered = Dnsruby::Types.MX
+    assert(rrset.add(sig))
+    assert(rrset.sigs.length == 1)
+    assert(rrset.num_sigs == 1)
+    assert(rrset.rrs.length == 3)
+    sig.name="example.co.uk"
+    assert(!rrset.add(sig))
+    assert(rrset.sigs.length == 1)
+    assert(rrset.num_sigs == 1)
+    assert(rrset.rrs.length == 3)
+  end
+end

data/test/tc_rrsig.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+require 'dnsruby'
+
+class RrsigTest < Test::Unit::TestCase
+  INPUT = "host.example.com. 86400 IN RRSIG A 5 3 86400 20030322173103 ( " + 
+    "20030220173103 2642 example.com. " +
+    "oJB1W6WNGv+ldvQ3WDG0MQkg5IEhjRip8WTr" +
+    "PYGv07h108dUKGMeDPKijVCHX3DDKdfb+v6o" +
+    "B9wfuh3DTJXUAfI/M0zmO/zz8bW0Rznl8O3t" +
+    "GNazPwQKkRN20XPXV6nwwfoXmJQbsLNrLfkG" +
+    "J5D6fwFm8nN+6pBzeDQfsS3Ap3o= )"
+  def test_rrsig_from_string
+    rrsig = Dnsruby::RR.create(INPUT)
+    
+    assert_equal(Dnsruby::Types.A, rrsig.type_covered)
+    assert_equal(Dnsruby::Algorithms::RSASHA1, rrsig.algorithm)
+    assert_equal(3, rrsig.labels)
+    assert_equal(86400, rrsig.original_ttl)
+    assert_equal(Time.mktime(2003,03,22,17,31, 03).to_i, rrsig.expiration)
+    assert_equal(Time.mktime(2003,02,20,17,31,03).to_i, rrsig.inception)
+    assert_equal(2642, rrsig.key_tag)
+    assert_equal(Dnsruby::Name.create("example.com."), rrsig.signers_name)
+    assert_equal("oJB1W6WNGv+ldvQ3WDG0MQkg5IEhjRip8WTr" +
+    "PYGv07h108dUKGMeDPKijVCHX3DDKdfb+v6o" +
+    "B9wfuh3DTJXUAfI/M0zmO/zz8bW0Rznl8O3t" +
+    "GNazPwQKkRN20XPXV6nwwfoXmJQbsLNrLfkG" +
+    "J5D6fwFm8nN+6pBzeDQfsS3Ap3o=", ([rrsig.signature].pack("m*")).gsub(/\n/,"").chomp)
+    
+    rrsig2 = Dnsruby::RR.create(rrsig.to_s)
+    assert(rrsig2.to_s == rrsig.to_s)
+  end
+end

data/test/tc_single_resolver.rb

@@ -0,0 +1,169 @@
+#--
+#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 TestSingleResolver < Test::Unit::TestCase
+  Thread::abort_on_exception = true
+  #  Dnsruby::TheLog.level=Logger::DEBUG
+  
+  def setup
+    Dnsruby::Config.reset
+  end
+  
+  Rrs = [
+    {
+      :type   		=> Types.A,
+      :name   		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :address 	=> '10.0.1.128'
+    },
+    {
+      :type		=> Types::MX,
+      :name		=> 'mx.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :exchange	=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :preference 	=> 10
+    },
+    {
+      :type		=> 'CNAME',
+      :name		=> 'cname.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :domainname		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk'
+    },
+    {
+      :type		=> Types.TXT,
+      :name		=> 'txt.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :strings		=> ['Net-DNS']
+    }		
+  ]		
+  
+  def test_simple
+    res = SingleResolver.new()
+    m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+  end
+  
+  def test_timeout
+    if (!RUBY_PLATFORM=~/darwin/)
+      # Run a query which will not respond, and check that the timeout works
+      begin
+        res = SingleResolver.new("10.0.1.128")
+        res.port = port
+        res.packet_timeout=1
+        m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+        fail
+      rescue ResolvTimeout
+      end
+    end
+  end
+  
+  def test_queue_timeout
+    port = 46129
+    if (!RUBY_PLATFORM=~/darwin/)
+      res = SingleResolver.new("10.0.1.128")
+      res.port = port
+      res.packet_timeout=1
+      q = Queue.new
+      msg = Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+      res.send_async(msg, q, msg)
+      id,ret, error = q.pop
+      assert(id==msg)
+      assert(ret==nil)
+      assert(error.class == ResolvTimeout)
+    end
+  end
+  
+  def test_queries
+    res = SingleResolver.new
+    
+    Rrs.each do |data|
+      packet=nil
+      2.times do 
+        begin
+          packet = res.query(data[:name], data[:type])
+        rescue ResolvTimeout
+        end
+        break if packet
+      end
+      assert(packet)
+      assert_equal(packet.question[0].qclass,    'IN',             'Class correct'           )
+      
+      assert(packet, "Got an answer for #{data[:name]} IN #{data[:type]}")
+      assert_equal(1, packet.header.qdcount, 'Only one question')
+      assert_equal(1, packet.header.ancount, 'Got single answer')
+      
+      question = (packet.question)[0]
+      answer   = (packet.answer)[0]
+      
+      assert(question,                           'Got question'            )
+      assert_equal(data[:name],  question.qname.to_s,  'Question has right name' )
+      assert_equal(Types.new(data[:type]),  question.qtype,  'Question has right type' )
+      assert_equal('IN',             question.qclass.string, 'Question has right class')
+      
+      assert(answer)
+      assert_equal(answer.klass,    'IN',             'Class correct'           )
+      
+      
+      data.keys.each do |meth| 
+        if (meth == :type)
+          assert_equal(Types.new(data[meth]).to_s, answer.send(meth).to_s, "#{meth} correct (#{data[:name]})") 
+        else       
+          assert_equal(data[meth].to_s, answer.send(meth).to_s, "#{meth} correct (#{data[:name]})") 
+        end
+      end
+    end # do
+  end # test_queries
+  
+  # @TODO@ Although the test_thread_stopped test runs in isolation, it won't run as part
+  # of the whole test suite (ts_dnsruby.rb). Commented out until I can figure out how to 
+  # get Test::Unit to run this one sequentially...  
+  #  def test_thread_stopped
+  #    res=SingleResolver.new
+  #    # Send a query, and check select_thread running.
+  #    m = res.query("example.com")
+  #    assert(Dnsruby::SelectThread.instance.select_thread_alive?)
+  #    # Wait a second, and check select_thread stopped.
+  #    sleep(2)
+  #    assert(!Dnsruby::SelectThread.instance.select_thread_alive?)
+  #    # Send another query, and check select_thread running.
+  #    m = res.query("example.com")
+  #    assert(Dnsruby::SelectThread.instance.select_thread_alive?)
+  #  end
+  
+  def test_persistent_socket
+    #@TODO@ Really need a test server for this one!
+    p "Implement persistent sockets!"
+  end
+  
+  def test_res_config
+    res = Dnsruby::SingleResolver.new
+    
+    res.server=('a.t.dnsruby.validation-test-servers.nominet.org.uk')
+    ip = res.server
+    assert_equal('10.0.1.128', ip, 'nameserver() looks up IP.')
+    
+    res.server=('cname.t.dnsruby.validation-test-servers.nominet.org.uk')
+    ip = res.server
+    assert_equal(ip, '10.0.1.128', 'nameserver() looks up cname.')
+  end
+  
+  def test_truncated_response
+    res = SingleResolver.new
+    res.server=('ns0.validation-test-servers.nominet.org.uk')
+    res.packet_timeout = 15
+    m = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", 'txt')
+    assert(m.header.ancount == 61, "61 answer records expected, got #{m.header.ancount}")
+    assert(!m.header.tc, "Message was truncated!")
+  end
+end