pNet-DNS 0.0.1

data/test/tc_rr-txt.rb

@@ -0,0 +1,138 @@
+# The contents of this file are subject to the Mozilla
+# Public Licence Version 1.1 (the "Licence"); you may
+# not use this file except in compliance with the
+# Licence. You may obtain a copy of the Licence at
+# http://www.mozilla.org/MPL
+# Software distributed under the Licence is distributed
+# on an "AS IS" basis,  WITHOUT WARRANTY OF ANY KIND,
+# either express or implied. See the Licence of the
+# specific language governing rights and limitations
+# under the Licence.
+# The Original Code is pNet::DNS.
+# The Initial Developer of the Original Code is
+# Nominet UK (www.nominet.org.uk). Portions created by
+# Nominet UK are Copyright (c) Nominet UK 2006.
+# All rights reserved.
+require 'test/unit'
+require 'Net/DNS'
+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|
+      puts(test_hr.inspect)
+      assert( uut = Net::DNS::RR.create(rr_base + test_hr[:stim]), 	
+      test_hr[:descr] + " -- Stimulus " ) 
+      
+      print "\nuut : " + uut.inspect + "\n"
+      
+      assert_equal(test_hr[:rdatastr], uut.rdatastr(), 			
+      test_hr[:descr] + " -- Response ( rdatastr ) " ) 
+      
+      list = uut.char_str_list()	
+      
+      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
+    
+    # RR.new_from_hash() drops stuff straight into the hash and 
+    # re-blesses it, breaking encapsulation.
+    
+    work_hash = {
+	:name		=> name,
+	:ttl		=> ttl,
+	:rrclass		=> 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[:txtdata] = %<no quotes>
+
+    uut = Net::DNS::RR.create(work_hash)    
+    assert( uut , 		# 30
+    "RR.new_from_hash with txtdata -- Stimulus")
+    assert( uut.rdatastr() == %<"no" "quotes">, 		# 31
+    "RR.new_from_hash with txtdata -- Response (rdatastr())")
+    
+    assert( uut.rr_rdata() == rdata , "TXT.rr_rdata" )	# 32
+    
+    
+  end
+end

data/test/tc_rr-unknown.rb

@@ -0,0 +1,95 @@
+# The contents of this file are subject to the Mozilla
+# Public Licence Version 1.1 (the "Licence"); you may
+# not use this file except in compliance with the
+# Licence. You may obtain a copy of the Licence at
+# http://www.mozilla.org/MPL
+# Software distributed under the Licence is distributed
+# on an "AS IS" basis,  WITHOUT WARRANTY OF ANY KIND,
+# either express or implied. See the Licence of the
+# specific language governing rights and limitations
+# under the Licence.
+# The Original Code is pNet::DNS.
+# The Initial Developer of the Original Code is
+# Nominet UK (www.nominet.org.uk). Portions created by
+# Nominet UK are Copyright (c) Nominet UK 2006.
+# All rights reserved.
+require 'test/unit'
+require 'Net/DNS'
+class TestRrUnknown < Test::Unit::TestCase
+  def test_RrUnknown
+    assert_equal(10226, Net::DNS::typesbyname('TYPE10226'), 'typesbyname(TYPE10226) returns 10226')
+    assert_equal('TYPE10226', Net::DNS::typesbyval(10226),        'typesbyval(10226) returns TYPE10226')
+    assert_equal('A', Net::DNS::typesbyval(1),           '       typesbyval(1) returns A')
+    
+    assert_equal(Net::DNS::typesbyval(Net::DNS::typesbyname('TYPE001')), 'A', 'typesbyval(typebyname(TYPE001)) returns A')
+    
+    
+    begin
+      Net::DNS::typesbyval(0xffff+1)
+      flunk("Should fail on large TYPE code")
+    rescue Exception
+    end
+    
+    assert_equal(Net::DNS::classesbyname('CLASS124'), 124,       'classesbyname(CLASS124) returns 124')
+    assert_equal(Net::DNS::classesbyval(125),         'CLASS125','classesbyval(125) returns CLASS125')
+    assert_equal(Net::DNS::classesbyval(1),           'IN',      'classesbyval(1) returns IN')
+    
+    assert_equal('HS', Net::DNS::classesbyval(Net::DNS::classesbyname('CLASS04')), 'classesbyval(typebyname(CLASS04)) returns HS')
+    
+    begin
+      Net::DNS::classesbyval(0xffff+1)
+      flunk("Should fail on large CLASS code")
+    rescue Exception
+    end
+  end
+  
+  def test_rr_new
+    rr = Net::DNS::RR.create('e.example CLASS01 TYPE01 10.0.0.2')
+    assert_equal('A', rr.type,  'TYPE01 parsed OK')
+    assert_equal('IN', rr.rrclass,'CLASS01 parsed OK')
+    
+    rr = Net::DNS::RR.create('e.example IN A \# 4  0A0000 01  ')
+    assert_equal('10.0.0.1', rr.address,'Unknown RR representation for A parsed OK')
+    
+    begin
+      res=Net::DNS::RR.create('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 = Net::DNS::RR.create('e.example IN TYPE4555 \# 4  0A0000 01  ')
+    assert_equal('e.example.	0	IN	TYPE4555	\# 4 0a000001', rr.inspect, 'Fully unknown RR parsed correctly')
+    
+    rr4 = Net::DNS::RR.create('e.example CLASS122 TYPE4555 \# 4  0A0000 01  ')
+    assert_equal('e.example.	0	CLASS122	TYPE4555	\# 4 0a000001', rr4.inspect, '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::DNS::Packet.new_from_binary(packetdata)
+    
+    string_representation = (packet.answer)[0].inspect
+    #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

data/test/tc_rr.rb

@@ -0,0 +1,246 @@
+# The contents of this file are subject to the Mozilla
+# Public Licence Version 1.1 (the "Licence"); you may
+# not use this file except in compliance with the
+# Licence. You may obtain a copy of the Licence at
+# http://www.mozilla.org/MPL
+# Software distributed under the Licence is distributed
+# on an "AS IS" basis,  WITHOUT WARRANTY OF ANY KIND,
+# either express or implied. See the Licence of the
+# specific language governing rights and limitations
+# under the Licence.
+# The Original Code is pNet::DNS.
+# The Initial Developer of the Original Code is
+# Nominet UK (www.nominet.org.uk). Portions created by
+# Nominet UK are Copyright (c) Nominet UK 2006.
+# All rights reserved.
+require 'test/unit'
+require 'Net/DNS'
+class TestRR < Test::Unit::TestCase
+  # @todo Add DNSSEC stuff when DNSSEC exists
+  def test_rr
+    #------------------------------------------------------------------------------
+    # Canned data.
+    #------------------------------------------------------------------------------
+    
+    name			= "foo.example.com";
+    klass			= "IN";
+    ttl				= 43200;
+    
+    rrs = [
+    {  	#[0]
+		:type        => 'A',
+	 	:address     => '10.0.0.1',  
+    }, 
+    {	#[1]
+		:type      => 'AAAA',
+		:address     => '102:304:506:708:90a:b0c:d0e:ff10',
+    }, 
+    {	#[2]
+		:type         => 'AFSDB',
+		:subtype      => 1,
+		:hostname     => 'afsdb-hostname.example.com',
+    }, 
+    {	#[3]
+		:type         => 'CNAME',
+		:cname        => 'cname-cname.example.com',
+    }, 
+    {   #[4]
+		:type         => 'DNAME',
+		:dname        => 'dname.example.com',
+    },
+    {	#[5]
+		:type         => 'HINFO',
+		:cpu          => 'test-cpu',
+		:os           => 'test-os',
+    }, 
+    {	#[6]
+		:type         => 'ISDN',
+		:address      => '987654321',
+		:sa           => '001',
+    }, 
+    {	#[7]
+		:type         => 'MB',
+		:madname      => 'mb-madname.example.com',
+    }, 
+    {	#[8]
+		:type         => 'MG',
+		:mgmname      => 'mg-mgmname.example.com',
+    }, 
+    {	#[9]
+		:type         => 'MINFO',
+		:rmailbx      => 'minfo-rmailbx.example.com',
+		:emailbx      => 'minfo-emailbx.example.com',
+    }, 
+    {	#[10]
+		:type         => 'MR',
+		:newname      => 'mr-newname.example.com',
+    }, 
+    {	#[11]
+		:type         => 'MX',
+		:preference   => 10,
+		:exchange     => 'mx-exchange.example.com',
+    },
+    {	#[12]
+		:type        => 'NAPTR',
+		:order        => 100,
+		:preference   => 10,
+		:flags        => 'naptr-flags',
+		:service      => 'naptr-service',
+		:regexp       => 'naptr-regexp',
+		:replacement  => 'naptr-replacement.example.com',
+    },
+    {	#[13]
+		:type         => 'NS',
+		:nsdname      => 'ns-nsdname.example.com',
+    },
+    {	#[14]
+		:type         => 'NSAP',
+		:afi          => '47',
+		:idi          => '0005',
+		:dfi          => '80',
+		:aa           => '005a00',
+		:rd           => '1000',
+		:area         => '0020',
+		:id           => '00800a123456',
+		:sel          => '00',
+    },
+    {	#[15]
+		:type         => 'PTR',
+		:ptrdname     => 'ptr-ptrdname.example.com',
+    },
+    {	#[16] 
+		:type         => 'PX',
+		:preference   => 10,
+		:map822       => 'px-map822.example.com',
+		:mapx400      => 'px-mapx400.example.com',
+    },
+    {	#[17]
+		:type         => 'RP',
+		:mbox		 => 'rp-mbox.example.com',
+		:txtdname     => 'rp-txtdname.example.com',
+    },
+    {	#[18]
+		:type         => 'RT',
+		:preference   => 10,
+		:intermediate => 'rt-intermediate.example.com',
+    },
+    {	#[19]
+		:type         => 'SOA',
+		:mname        => 'soa-mname.example.com',
+		:rname        => 'soa-rname.example.com',
+		:serial       => 12345,
+		:refresh      => 7200,
+		:retry        => 3600,
+		:expire       => 2592000,
+		:minimum      => 86400,
+    },
+    {	#[20]
+		:type         => 'SRV',
+		:priority     => 1,
+		:weight       => 2,
+		:port         => 3,
+		:target       => 'srv-target.example.com',
+    },
+    {	#[21]
+		:type         => 'TXT',
+		:txtdata      => 'txt-txtdata',
+    },
+    {	#[22]
+		:type         => 'X25',
+		:psdn         => 123456789,
+    },
+    {	#[23]
+		:type        => 'LOC',
+		:version      => 0,
+		:size         => 3000,
+		:horiz_pre    => 500000,
+		:vert_pre     => 500,
+		:latitude     => 2001683648,
+		:longitude    => 1856783648,
+		:altitude     => 9997600,
+    }, 	#[24]
+    {
+		:type         => 'CERT',
+		:format     => 3,
+		:tag			 => 1,
+		:algorithm    => 1,
+		:certificate  => '123456789abcdefghijklmnopqrstuvwxyz',
+    },
+    
+    {	#[25]
+		:type         => 'SPF',
+		:txtdata      => 'txt-txtdata',
+    },
+    ]
+    
+    
+    
+    
+    
+    #------------------------------------------------------------------------------
+    # Create the packet
+    #------------------------------------------------------------------------------
+    
+    packet = Net::DNS::Packet.new_from_values(name);
+    assert(packet,         'Packet created');
+    
+    rrs.each do |data|
+      data.update({	   :name => name,
+	   :ttl  => ttl,
+      })
+      rr=Net::DNS::RR.create(data)
+      
+      packet.push('answer', rr );
+    end
+    
+    
+    #------------------------------------------------------------------------------
+    # Re-create the packet from data.
+    #------------------------------------------------------------------------------
+    
+    data = packet.data;
+    assert(data,            'Packet has data after pushes');
+    
+    packet=nil;
+    packet = Net::DNS::Packet.new_from_binary(data);
+    
+    assert(packet,          'Packet reconstructed from data');
+    
+    answer = packet.answer;
+    
+    puts(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)
+        assert_equal(value, x, "Packet returned wrong answer section for #{ret_rr.to_s}, #{key}")
+      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,    "#{type} - name() correct");         
+      assert_equal(klass,      	rr.rrclass,   "#{type} - class() correct");  
+      assert_equal(ttl,        	rr.ttl,     "#{type} - ttl() correct");                
+      
+      #	foreach my $meth (keys %{data}) {
+      data.keys.each do |meth|
+        
+        assert_equal(data[meth], rr.send(meth), "#{type} - #{meth}() correct");
+      end
+      
+      rr2 = Net::DNS::RR.create(rr.inspect);
+      assert_equal(rr.inspect,   rr2.inspect, "#{type} - Parsing from string works");
+    end
+  end
+end