dnsruby 1.55 → 1.56.0

data/test/tc_rr-opt.rb

@@ -1,51 +1,58 @@
-#--
-#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.
-#++
-begin
-  require 'rubygems'
-rescue LoadError
-end
-require 'test/unit'
-require 'dnsruby'
+# --
+# 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_relative 'spec_helper'
+
 require 'socket'
+
 include Dnsruby
-class TestRrOpt < Test::Unit::TestCase
+class TestRrOpt < Minitest::Test
   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")
-    
+
+    optrr.set_client_subnet("0.0.0.0/0")
+    assert_equal(optrr.edns_client_subnet,"0.0.0.0/0/0","Wildcard Address")
+    optrr.set_client_subnet("216.253.14.2/24")
+    assert_equal(optrr.edns_client_subnet,"216.253.14.0/24/0","IPv4 subnet")
+    optrr.set_client_subnet("216.253.14.2/1")
+    assert_equal(optrr.edns_client_subnet,"216.0.0.0/1/0","IPv4 subnet <8 bits")
+    optrr.set_client_subnet("2600:3c00:0:91fd:ab77:157e::/64")
+    assert_equal(optrr.edns_client_subnet,"2600:3c00:0:91fd::/64/0","IPv6 subnet")
+    optrr.set_client_subnet("2600:3c00:0:91fd:ab77:157e::/7")
+    assert_equal(optrr.edns_client_subnet,"2600::/7/0","IPv6 subnet <8 bits")
   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.
+    #  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.
     Dnsruby::PacketSender.clear_caches
     socket = UDPSocket.new
     socket.bind("127.0.0.1", 0)
@@ -58,62 +65,62 @@ class TestRrOpt < Test::Unit::TestCase
       q.push(Message.decode(received_query))
       socket.send(received_query,0)
     }
-    
-    # Now send query
+
+    #  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
+
+    #  Now get received query from the server
     p = q.pop
-    # Now check the query was what we expected
+    #  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
+    #  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.rcode == RCode.NoError)
   end
-  
+
   def test_decode_opt
-    # Create an OPT RR
+    #  Create an OPT RR
     size=2048;
     ednsflags=0x9e22;
     optrr = RR::OPT.new(size, ednsflags)
-    
-    # Add it to a message
+
+    #  Add it to a message
     m = Message.new
     m.add_additional(optrr)
-    
-    # Encode the message
+
+    #  Encode the message
     data = m.encode
-   
-    # Decode it
+
+    #  Decode it
     m2 = Message.decode(data)
-    
-    # Make sure there is an OPT RR there
+
+    #  Make sure there is an OPT RR there
     assert(m2.rcode == RCode.NOERROR  )
   end
 
   def test_formerr_response
-    # If we get a FORMERR back from the remote resolver, we should retry with no OPT record
-    # So, we need a server which sends back FORMERR for OPT records, and is OK without them.
-    # Then, we need to get a client to send a request to it (by default adorned with EDNS0),
-    # and make sure that the response is returned to the client OK.
-    # We should then check that the server only received one message with EDNS0, and one message
-    # without.
+    #  If we get a FORMERR back from the remote resolver, we should retry with no OPT record
+    #  So, we need a server which sends back FORMERR for OPT records, and is OK without them.
+    #  Then, we need to get a client to send a request to it (by default adorned with EDNS0),
+    #  and make sure that the response is returned to the client OK.
+    #  We should then check that the server only received one message with EDNS0, and one message
+    #  without.
     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.
+    #  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.
     Dnsruby::PacketSender.clear_caches
     socket = UDPSocket.new
     socket.bind("127.0.0.1", 0)
@@ -126,7 +133,7 @@ class TestRrOpt < Test::Unit::TestCase
         m = Message.decode(received_query)
         q.push(m)
         if (m.header.arcount > 0)
-          # send back FORMERR
+          #  send back FORMERR
           m.header.rcode = RCode.FORMERR
           socket.send(m.encode,0,s[1][2], s[1][1])
         else
@@ -135,7 +142,7 @@ class TestRrOpt < Test::Unit::TestCase
       }
 
     }
-    # Now send query
+    #  Now send query
     res = Resolver.new("127.0.0.1")
     res.port = port
     res.udp_size = 4096
@@ -144,14 +151,14 @@ class TestRrOpt < Test::Unit::TestCase
     assert(ret.header.get_header_rcode == RCode.NOERROR)
     assert(ret.header.arcount == 0)
 
-    # Now get received query from the server
+    #  Now get received query from the server
     p = q.pop
-    # Now check the query was what we expected
+    #  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)
 
-    # Now check the second message
+    #  Now check the second message
     assert (!(q.empty?))
     p2 = q.pop
     assert (p2)

data/test/tc_rr-txt.rb

@@ -1,28 +1,25 @@
-#--
-#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.
-#++
-begin
-require 'rubygems'
-rescue LoadError
-end
-require 'test/unit'
-require 'dnsruby'
+# --
+# 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_relative 'spec_helper'
+
 include Dnsruby
-class TestRrTest < Test::Unit::TestCase
-  #Stimulus, expected response, and test name:
-  
+class TestRrTest < Minitest::Test
+  # Stimulus, expected response, and test name:
+
   TESTLIST =	[
   {	# 2-5
     :stim		=>	%<"">,
@@ -60,82 +57,82 @@ class TestRrTest < Test::Unit::TestCase
     :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',
-  #    }
+  #  @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.
-    #------------------------------------------------------------------------------
-    
+    # ------------------------------------------------------------------------------
+    #  Canned data.
+    # ------------------------------------------------------------------------------
+
     name			= 'foo.example.com';
     klass			= 'IN';
     type			= 'TXT';
     ttl				= 43201;
-    
+
     rr_base	= [name, ttl, klass, type, "    " ].join(' ')
-    
-    
-    #------------------------------------------------------------------------------
-    # Run the tests
-    #------------------------------------------------------------------------------
-    
+
+
+    # ------------------------------------------------------------------------------
+    #  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( 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"  ) 		
+                   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.").
-    
+
+
+    #  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)    
+
+    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
 
   def test_nasty_txt

data/test/tc_rr-unknown.rb

@@ -1,98 +1,95 @@
-#--
-#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.
-#++
-begin
-require 'rubygems'
-rescue LoadError
-end
-require 'test/unit'
-require 'dnsruby'
+# --
+# 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_relative 'spec_helper'
+
 include Dnsruby
-class TestRrUnknown < Test::Unit::TestCase
+class TestRrUnknown < Minitest::Test
   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')
+      # 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 
+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*", "")
-    
+
+    #     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 =~ s/\s+/ /g,
     string_representation = string_representation.gsub(/\s+/, " ")
     assert_equal(
 	'TEST.example.com. 123 IN TYPE12345 \# 10 1122334455aabbccddee',