dnsruby 1.60.2 → 1.73.0

data/test/tc_dns.rb

@@ -25,7 +25,7 @@ class TestDNS < Minitest::Test
   end
 
   def test_ipv4_address
-    Dnsruby::DNS.open { |dns| dns.getnames(Dnsruby::IPv4.create("221.186.184.68")) }
+    Dnsruby::DNS.open { |dns| dns.getnames(Dnsruby::IPv4.create("8.8.8.8")) }
   end
 
   # def test_resolv_rb_api
@@ -167,9 +167,9 @@ class TestDNS < Minitest::Test
   end # test_online
 
   def test_search_query_reverse
-    # 
+    #
     #  test that getname() DTRT with reverse lookups
-    # 
+    #
     tests = [
     {
       :ip => '198.41.0.4',
@@ -183,7 +183,7 @@ class TestDNS < Minitest::Test
 
     res = DNS.new
     tests.each do |test|
-      name = res.getname(test[:ip])
+      name = with_retries { res.getname(test[:ip]) }
 
       assert_instance_of(Name,name)
 
@@ -235,7 +235,7 @@ class TestDNS < Minitest::Test
         res.config.apply_search_list=true
       end
 
-      ans, query = res.send_query(test[:name])
+      ans, _ = res.send_query(test[:name])
 
       assert_instance_of(Message, ans)
 
@@ -247,6 +247,16 @@ class TestDNS < Minitest::Test
       assert_equal(a[0].name.to_s, 'a.t.net-dns.org',"Correct name (with persistent socket and #{method})")
       # assert_equal(a[0].name.to_s, 'a.t.dnsruby.validation-test-servers.nominet.org.uk',"Correct name (with persistent socket and #{method})")
     end
+  end
 
+  def test_port
+    d = DNS.new({:port => 5353})
+    assert(d.to_s.include?"5353")
   end
+
+  def test_port_nil
+    d = DNS.new({:port => nil})
+    assert(d.to_s.include? Dnsruby::Config::DEFAULT_PORT.to_s)
+  end
+
 end

data/test/tc_dnskey.rb

@@ -85,4 +85,33 @@ class DnskeyTest < Minitest::Test
     dnskey.protocol=3
 
   end
+
+  def test_ecdsa_integrity
+    ecdsa_256_pub = 'example.com. 3600 IN DNSKEY 256 3 13 ( oJMRESz5E4gYzS/q6XD' +
+    'rvU1qMPYIjCWzJaOau8XNEZeqCYKD5ar0IRd8KqXXFJkqmVfRvMGPmM1x8fGAa2XhSA== )'
+
+    dnskey = Dnsruby::RR.create(ecdsa_256_pub)
+    assert_equal(3, dnskey.protocol)
+    assert_equal(256, dnskey.flags)
+    assert_equal(Dnsruby::Algorithms::ECDSAP256SHA256, dnskey.algorithm)
+    assert_equal(Dnsruby::RR::DNSKEY::ZONE_KEY, dnskey.flags & Dnsruby::RR::DNSKEY::ZONE_KEY)
+    assert_equal(0, dnskey.flags & Dnsruby::RR::DNSKEY::SEP_KEY)
+
+    dnskey2 = Dnsruby::RR.create(dnskey.to_s)
+    assert(dnskey2.to_s == dnskey.to_s, "#{dnskey} not equal to \n#{dnskey2}")
+
+    ecdsa_384_pub = 'example.com. 3600 IN DNSKEY 256 3 14 ( Bl2HDw98sGin4lNlx7n' +
+    'QX3w98jx6UhAgC73Jq+6LFlD12gnVTMHecM8Z GoTFSh+mV+qEPFZ5s3NbC4qvwUW0kkPb+0ip' +
+    'CuLRwZYhYKk7D+RDb+fX XozI9hhZrsXBcEhss )'
+
+    dnskey = Dnsruby::RR.create(ecdsa_384_pub)
+    assert_equal(3, dnskey.protocol)
+    assert_equal(256, dnskey.flags)
+    assert_equal(Dnsruby::Algorithms::ECDSAP384SHA384, dnskey.algorithm)
+    assert_equal(Dnsruby::RR::DNSKEY::ZONE_KEY, dnskey.flags & Dnsruby::RR::DNSKEY::ZONE_KEY)
+    assert_equal(0, dnskey.flags & Dnsruby::RR::DNSKEY::SEP_KEY)
+
+    dnskey2 = Dnsruby::RR.create(dnskey.to_s)
+    assert(dnskey2.to_s == dnskey.to_s, "#{dnskey} not equal to \n#{dnskey2}")
+  end
 end

data/test/tc_ecdsa.rb

@@ -0,0 +1,27 @@
+require_relative 'spec_helper'
+
+Dnsruby::TheLog.level = Logger::DEBUG
+
+class VerifierTest < Minitest::Test
+
+  def test_ecdsa
+    inner_resolver = Dnsruby::Resolver.new
+    inner_resolver.do_validation = true
+    inner_resolver.dnssec = true
+    resolver = Dnsruby::Recursor.new(inner_resolver)
+    resolver.dnssec = true
+
+    #    Dnsruby::TheLog.level=Logger::DEBUG
+
+    name = 'carlgo11.com'
+    type = 'A'
+    klass = 'IN'
+
+    begin
+      answer = resolver.query(name, type, klass)
+      print answer
+    rescue Exception => e
+      fatal_error("query failed: #{e}")
+    end
+  end
+end

data/test/tc_encoding.rb

@@ -0,0 +1,31 @@
+require_relative 'spec_helper'
+
+require 'socket'
+
+# @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 TestEncoding < Minitest::Test
+
+  include Dnsruby
+
+  Thread::abort_on_exception = true
+
+  Dnsruby::TheLog.level = Logger::DEBUG
+
+
+  def test_cdnskey
+    rrString = "tjeb.nl.\t3600\tIN\tCDNSKEY\t256 3 RSASHA1-NSEC3-SHA1 ( AwEAAcglEOS7bECRK5fqTuGTMJycmDhTzmUu/EQbAhKJOYJxDb5SG/RYqsJgzG7wgtGy0W1aP7I4k6SPtHmwcqjLaZLVUwRNWCGr2adjb9JTFyBR7F99Ngi11lEGM6Uiw/eDRk66lhoSGzohjj/rmhRTV6gN2+0ADPnafv3MBkPgryA3 ) ; key_tag=53177"
+    rr = RR.create(rrString)
+    puts rr
+    puts rrString
+    assert(rrString.to_s == rr.to_s)
+    m = Dnsruby::Message.new
+    m.add_additional(rr)
+    m2 = Message.decode(m.encode)
+    rr2 = m2.additional()[0]
+    assert(rr.to_s == rr2.to_s)
+  end
+end

data/test/tc_escapedchars.rb

@@ -350,7 +350,7 @@ d0
     packet     = Message.decode(packetdata)
     assert_equal( '\\\\e.eg.secret-wg.org',(packet.answer)[0].name.to_s,"Correctly dealt escaped backslash from wireformat \\\..eg.secret-wg.org")
 
-    testrr=RR.create(
+    RR.create(
                            :name => '\\e.eg.secret-wg.org',
     :type         => 'TXT',
     :txtdata      => '"WildCard Match"',
@@ -360,7 +360,6 @@ d0
 
 
 
-    klass = "IN"
     ttl = 43200
     name = 'def0au&lt.example.com'
 
@@ -471,17 +470,17 @@ d0
       type = data[:type]
       # 		foreach my $meth (keys %{$data}) {
        (data.keys.each do |meth|
-        if (meth == :type)
-          assert_equal(Types.new(data[meth]).to_s, rr.send(meth).to_s, "#{type} - #meth() correct")
-        else
-          assert_equal(data[meth].to_s, rr.send(meth).to_s, "#{type} - #meth() correct")
-        end
+          if (meth == :type)
+            assert_equal(Types.new(data[meth]).to_s, rr.send(meth).to_s, "#{type} - #meth() correct")
+          else
+            assert_equal(data[meth].to_s, rr.send(meth).to_s, "#{type} - #meth() correct")
+          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
 
     Name::Label.set_max_length(Name::Label::MaxLabelLength)
-    end
   end
+end

data/test/tc_gpos.rb

@@ -93,7 +93,7 @@ class TestGPOS < Minitest::Test
     response_binary = "E0\x84\x80\x00\x01\x00\x01\x00\x01\x00\x01\x01a\adnsruby\x03com\x00\x00\e\x00\x01\xC0\f\x00\e\x00\x01\x00\x00*0\x00\x0F\x0410.0\x0420.0\x0430.0\xC0\x0E\x00\x02\x00\x01\x00\x00*0\x00\x06\x03ns1\xC0\x0E\xC0F\x00\x01\x00\x01\x00\x00*0\x00\x04\x7F\x00\x00\x01"
     message_object = Message.decode(response_binary)
     reconstructed_binary = message_object.encode
-    assert_equal response_binary.force_encoding('ASCII-8BIT'), reconstructed_binary
+    assert_equal response_binary.b, reconstructed_binary
   end
 end
 

data/test/tc_hs.rb

@@ -2,21 +2,17 @@ require_relative 'spec_helper'
 
 class TestDNS < Minitest::Test
 
-  def setup
-    Dnsruby::Config.reset
-  end
-
-
   # Illustrates that when a message whose class is 'HS' is sent to
   # a DNS server that does not support the HS class, using send_plain_message,
   # the response returns with an rcode of NOTIMP and a Dnsruby::NotImp error.
   def test_hs_class_returns_notimp_code_and_error
     resolver_host = 'a.gtld-servers.net'
-    resolver = Resolver.new(resolver_host)
-    message = Message.new('test.com', 'A', 'HS')
+    resolver = Dnsruby::Resolver.new(resolver_host)
+    resolver.query_timeout = 20
+    message = Dnsruby::Message.new('test.com', 'A', 'HS')
     response, error = resolver.send_plain_message(message)
 
-    assert_equal(RCode::NOTIMP, response.rcode)
+    assert_equal(Dnsruby::RCode::NOTIMP, response.rcode)
     assert_equal(Dnsruby::NotImp, error.class)
   end
 

data/test/tc_long_labels.rb

@@ -0,0 +1,46 @@
+require_relative 'spec_helper'
+
+include Dnsruby
+class TestPacket < Minitest::Test
+  def test_labels
+    wirePacket = %w{0 
+      68 5b 35 91 3a f7 00 0f 94 22 d9 51 08 00 45 00 05 12 71 65 40 00 3d 06 46 1f 2e e3 90 33
+      c0 a8 01 a3 00 35 e3 cf 94 d5 49 0a 88 da e7 1e 80 18 00 1d 6f 52 00 00 01 01 08 0a 8e 3a
+      a6 b1 1f 4d ce 28 c5 b1 c0 0c 00 0c 00 01 00 00 0b 49 00 12 0f 69 6d 70 72 6f 76 65 61 6e
+      61 6c 79 73 69 73 c0 65 c0 0c 00 0c 00 01 00 00 0b 49 00 0e 0b 77 69 6e 64 6f 77 73 72 75
+      62 79 d3 12 c0 0c 00 0c 00 01 00 00 0b 49 00 15 12 6d 69 63 72 6f 73 6f 66 74 66 6f 72 65
+      66 72 6f 6e 74 d3 bd c0 0c 00 0c 00 01 00 00 0b 49 00 11 09 6d 69 63 72 6f 73 6f 66 74 02
+      63 6f 02 6d 7a 00 c0 0c 00 0c 00 01 00 00 0b 49 00 12 09 77 69 6e 64 6f 77 73 78 70 03 6f
+      72 67 02 70 65 00 c0 0c 00 0c 00 01 00 00 0b 49 00 16 0f 65 75 67 72 61 6e 74 73 61 64 76
+      69 73 6f 72 03 63 6f 6d ca 49 c0 0c 00 0c 00 01 00 00 0b 49 00 14 11 64 65 66 79 61 6c 6c
+      63 68 61 6c 6c 65 6e 67 65 73 c5 97 c0 0c 00 0c 00 01 00 00 0b 49 00 18 15 63 6f 6e 73 6f
+      6c 69 64 61 74 65 64 6d 65 73 73 65 6e 67 65 72 c0 65 c0 0c 00 0c 00 01 00 00 0b 49 00 19
+      16 72 65 74 61 69 6c 65 78 65 63 75 74 69 76 65 73 65 6d 69 6e 61 72 c0 a7 c0 0c 00 0c 00
+      01 00 00 0b 49 00 0e 0b 63 74 72 6f 70 65 6e 6f 72 6d 65 c0 65 c0 0c 00 0c 00 01 00 00 0b
+      49 00 0e 0b 77 69 6e 64 6f 77 73 32 30 30 30 cc 6f c0 0c 00 0c 00 01 00 00 0b 49 00 1a 17
+      77 69 6e 64 6f 77 73 6d 6f 62 69 6c 65 63 6f 6d 6d 6d 75 6e 69 74 79 c0 41 c0 0c 00 0c 00
+      01 00 00 0b 49 00 11 0e 72 69 73 65 6f 66 70 65 72 61 74 68 69 61 c0 41 c0 0c 00 0c 00 01
+      00 00 0b 49 00 11 0e 72 65 6e 63 6f 6e 74 72 65 73 2d 33 36 30 c0 41 c0 0c 00 0c 00 01 00
+      00 0b 49 00 11 0e 66 75 74 75 72 65 70 6f 73 74 6d 61 69 6c c0 41 c0 0c 00 0c 00 01 00 00
+      0b 49 00 10 0d 72 65 73 70 6f 6e 73 65 70 6f 69 6e 74 cc 4d c0 0c 00 0c 00 01 00 00 0b 49
+      00 10 0d 74 61 76 75 74 61 74 72 6f 6e 63 68 65 c0 a7 c0 0c 00 0c 00 01 00 00 0b 49 00 09
+      06 66 6c 65 78 67 6f df 34 c0 0c 00 0c 00 01 00 00 0b 49 00 0e 09 77 69 6e 64 6f 77 73 78
+      70 02 73 68 00 c0 0c 00 0c 00 01 00 00 0b 49 00 16 13 73 6d 61 72 74 70 68 6f 6e 65 63 6f
+      6d 6d 75 6e 69 74 79 c0 a7 c0 0c 00 0c 00 01 00 00 0b 49 00 12 0f 63 65 6e 74 72 65 64 65
+      73 75 73 61 67 65 73 c0 65 c0 0c 00 0c 00 01 00 00 0b 49 00 0c 09 77 69 6e 64 6f 77 73 6e
+      74 fc 07 c0 0c 00 0c 00 01 00 00 0b 49 00 19 16 6c 65 73 2d 64 6f 69 67 74 73 2d 64 61 6e
+      73 2d 6c 65 2d 6e 65 7a c0 a7 c0 0c 00 0c 00 01 00 00 0b 49 00 13 10 74 65 63 68 6e 65 74
+      63 68 61 6c 6c 65 6e 67 65 c0 65 c0 0c 00 0c 00 01 00 00 0b 49 00 15 12 6d 69 63 72 6f 73 6f 66 74 66 6f 72 65 66 72 6f 6e 74 c0 41 c0 0c 00 0c 00 01 00 00 0b 49 00 10 0d 6c 65 73 62 6f 6e 73 6f 75 74 69 6c 73 c0 41 c0 0c 00 0c 00 01 00 00 0b 49 00 0d 0a 77 69 6e 74 65 72 6e 61 6c 73 c3 d6 c0 0c 00 0c 00 01 00 00 0b 49 00 23 0e 64 65 73 69 67 6e 65 64 66 6f 72 62 69 67 02 64 65 0e 64 65 73 69 67 6e 65 64 66 6f 72 62 69 67 c2 b2 c0 0c 00 0c 00 01 00 00 0b 49 00 13 10 77 69 6e 64 6f 77 73 76 69 73 74 61 62 6c 6f 67 c9 42 c0 0c 00 0c 00 01 00 00 0b 49 00 12 09 77 69 6e 64 6f 77 73 6e 74 03 6f 72 67 02 66 6a 00 c0 0c 00 0c 00 01 00 00 0b 49 00 0c 09 77 69 6e 64 6f 77 73 6e 74 c1 b6 c0 0c 00 0c 00 01 00 00 0b 49 00 0f 0c 6f 66 66 69 63 65 73 79 73 74 65 6d c2 18 c0 0c 00 0c 00 01 00 00 0b 49 00 0f 0c 74 72 65 79 72 65 73 65 61 72 63 68 c0 41 c0 0c 00 0c 00 01 00 00 0b 49 00 09 06 63 70 61 6e 64 6c c0 65 c0 0c 00 0c 00 01 00 00 0b 49 00 16 13 6f 66 66 72 65 2d 65 62 6c 6f 75 69 73 73 61 6e 74 65 73 c0 41 c0 0c 00 0c 00 01 00 00 0b 49 00 0d 0a 63 6f 68 6f 77 69 6e 65 72 79 c0 41 c0 0c 00 0c 00 01 00 00 0b 49 00 13 10 74 6f 64 6f 73 6c 6f 65 6e 74 69 65 6e 64 65 6e c0 41 c0 0c 00 0c 00 01 00 00 0b 49 00 0f 09 77 69 6e 64 6f 77 73 78 70 02 63 6f f1 03 c0 0c 00 0c 00 01 00 00 0b 49 00 0b 08 74 65 63 68 65 64 30 36 c0 65 c0 0c 00 0c 00 01 00 00 0b 49 00 09 06 66 6c 65 78 67 6f dd 7f c0 0c 00 0c 00 01 00 00 0b 49 00 0c 09 66 6f 72 65 66 72 6f 6e 74 cb 21 c0 0c 00 0c 00 01 00 00 0b 49 00 14 11 64 65 66 79 61 6c 6c 63 68 61 6c 6c 65 6e 67 65 73 cb 44 00 00 29 05 78 00 00 80 00 00 00
+    }
+    wirePacket.map!{|e| e.hex}
+    packetdata = wirePacket.pack('c*')
+
+    packet = Message.decode(packetdata)
+    assert(packet,                                 'new data returned something');         #28
+  end
+
+  def test_live
+    resolver = Dnsruby::Resolver.new
+    query = resolver.query('207.46.197.32', 'PTR', 'IN')
+  end
+end

data/test/tc_message.rb

@@ -49,7 +49,7 @@ class TestMessage < Minitest::Test
   def test_rd_flag_displayed_when_true
     message = sample_message
     message.header.instance_variable_set(:@rd, true)
-    assert /;; flags(.+)rd/.match(message.to_s), message
+    assert(/;; flags(.+)rd/.match(message.to_s), message)
   end
 
   def test_header_line_contains_opcode_and_status_and_id
@@ -86,7 +86,7 @@ class TestMessage < Minitest::Test
   end
 
   def test_equals
-    response_as_string = "\x10\a\x81\x90\x00\x01\x00\x04\x00\x00\x00\x06\x03cnn\x03com\x00\x00\x02\x00\x01\xC0\f\x00\x02\x00\x01\x00\x01QC\x00\x14\x03ns3\ntimewarner\x03net\x00\xC0\f\x00\x02\x00\x01\x00\x01QC\x00\x11\x03ns2\x03p42\x06dynect\xC04\xC0\f\x00\x02\x00\x01\x00\x01QC\x00\x06\x03ns1\xC0)\xC0\f\x00\x02\x00\x01\x00\x01QC\x00\x06\x03ns1\xC0I\xC0%\x00\x01\x00\x01\x00\x001\xA2\x00\x04\xC7\aD\xEE\xC0E\x00\x01\x00\x01\x00\x00\xB1\x0E\x00\x04\xCC\r\xFA*\xC0b\x00\x01\x00\x01\x00\x009`\x00\x04\xCCJl\xEE\xC0t\x00\x01\x00\x01\x00\x00\xBDg\x00\x04\xD0NF*\xC0t\x00\x1C\x00\x01\x00\x00\x00\xBB\x00\x10 \x01\x05\x00\x00\x90\x00\x01\x00\x00\x00\x00\x00\x00\x00B\x00\x00)\x0F\xA0\x00\x00\x80\x00\x00\x00".force_encoding("ASCII-8BIT")
+    response_as_string = "\x10\a\x81\x90\x00\x01\x00\x04\x00\x00\x00\x06\x03cnn\x03com\x00\x00\x02\x00\x01\xC0\f\x00\x02\x00\x01\x00\x01QC\x00\x14\x03ns3\ntimewarner\x03net\x00\xC0\f\x00\x02\x00\x01\x00\x01QC\x00\x11\x03ns2\x03p42\x06dynect\xC04\xC0\f\x00\x02\x00\x01\x00\x01QC\x00\x06\x03ns1\xC0)\xC0\f\x00\x02\x00\x01\x00\x01QC\x00\x06\x03ns1\xC0I\xC0%\x00\x01\x00\x01\x00\x001\xA2\x00\x04\xC7\aD\xEE\xC0E\x00\x01\x00\x01\x00\x00\xB1\x0E\x00\x04\xCC\r\xFA*\xC0b\x00\x01\x00\x01\x00\x009`\x00\x04\xCCJl\xEE\xC0t\x00\x01\x00\x01\x00\x00\xBDg\x00\x04\xD0NF*\xC0t\x00\x1C\x00\x01\x00\x00\x00\xBB\x00\x10 \x01\x05\x00\x00\x90\x00\x01\x00\x00\x00\x00\x00\x00\x00B\x00\x00)\x0F\xA0\x00\x00\x80\x00\x00\x00".b
     message = Message.decode(response_as_string)
     assert(message == message, message.to_s)
   end

data/test/tc_name.rb

@@ -24,7 +24,7 @@ class TestName < Minitest::Test
     Name::Label.set_max_length(Name::Label::MaxLabelLength) # Other tests may have changed this
     #  Test max label length = 63
     begin
-      name = Name.create("a.b.12345678901234567890123456789012345678901234567890123456789012345.com")
+      Name.create("a.b.12345678901234567890123456789012345678901234567890123456789012345.com")
       assert(false, "Label of more than max=63 allowed")
     rescue ResolvError
     end
@@ -33,7 +33,7 @@ class TestName < Minitest::Test
   def test_name_length
     #  Test max name length=255
     begin
-      name = Name.create("1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123.com")
+      Name.create("1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123.com")
       assert(false, "Name of length > 255 allowed")
     rescue ResolvError
     end
@@ -80,4 +80,23 @@ class TestName < Minitest::Test
     n2 = Name.create("nall.all.")
     assert(n1 == n2, n1.to_s)
   end
+
+  def test_punycode
+    [
+      [
+        "møllerriis.com",
+        "xn--mllerriis-l8a.com"
+      ],
+      [
+        "フガフガ。hogehoge.エグザンプル.JP",
+        "xn--mcka5jb.hogehoge.xn--ickqs6k2dyb.jp"
+      ],
+      [
+        "フガ#フガ。hogehoge.エグザンプル.JP",
+        "xn--#-yeub5nc.hogehoge.xn--ickqs6k2dyb.jp"
+      ]
+    ].each do |tc|
+      assert_equal(Dnsruby::Name.create(tc[0]).to_s, tc[1])
+    end
+  end
 end

data/test/tc_nxt.rb

@@ -60,7 +60,6 @@ class TestNXT < Minitest::Test
   def test_binary_string_to_codes
     test_type_codes_as_code_array = [1, 6, 28, 100]
     test_type_codes_as_name_array = %w(A  SOA  AAAA  UINFO)
-    test_type_codes_as_number = 1267650600228229401496971640898  # (2 ** 1) + (2 ** 6) + (2 ** 28) + (2 ** 100)
     test_type_codes_as_binary_string = "\x10\x0\x0\x0\x0\x0\x0\x0\x0\x10\x0\x0\x42"
     assert_equal(test_type_codes_as_code_array, RR::NXT::NxtTypes.binary_string_to_codes(test_type_codes_as_binary_string))
     assert_equal(test_type_codes_as_name_array, RR::NXT::NxtTypes.binary_string_to_names(test_type_codes_as_binary_string))

data/test/tc_recur.rb

@@ -1,12 +1,12 @@
 # --
 # 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.
@@ -20,10 +20,7 @@ class TestRecur < Minitest::Test
   def test_recur
     Dnsruby::PacketSender.clear_caches
     r = Dnsruby::Recursor.new
-#    Dnsruby::TheLog.level = Logger::DEBUG
-    ret = r.query("uk", Dnsruby::Types.DNSKEY)
-#    print ret
-    assert ret, "Query result was nil."
+    ret = with_retries(max_attempts: 10, exceptions: [Dnsruby::ResolvError]) { r.query("uk", Dnsruby::Types.DNSKEY) }
     assert ret.answer.length > 0, "Answer length should > 0, but was #{ret.answer.length}."
 #    ret = r.query_dorecursion("aaa.bigzone.uk-dnssec.nic.uk", Dnsruby::Types.DNSKEY)
 #    ret = r.query_dorecursion("uk-dnssec.nic.uk", Dnsruby::Types.DNSKEY)

data/test/tc_resolv.rb

@@ -20,6 +20,7 @@ require_relative '../lib/dnsruby/resolv'
 class TestResolv < Minitest::Test
 
   RELATIVE_NAME = 'google-public-dns-a.google.com'
+  SHORT_ABSOLUTE_NAME = 'dns.google.'
   ABSOLUTE_NAME = RELATIVE_NAME + '.'
   IPV4_ADDR     = '8.8.8.8'
   IPV6_ADDR     = '2001:4860:4860::8888'
@@ -50,19 +51,26 @@ class TestResolv < Minitest::Test
     end
   end
 
-
   def test_resolv_address_to_name
 
-    assert_equal(RELATIVE_NAME, Dnsruby::Resolv.getname(IPV4_ADDR).to_s)
+    name = with_retries { Dnsruby::Resolv.getname(IPV4_ADDR) }
+    assert_equal(SHORT_ABSOLUTE_NAME, name.to_s(true))
 
     assert_raises(Dnsruby::ResolvError) do
-      Dnsruby::Resolv.getname(RELATIVE_NAME)
+      Dnsruby::Resolv.getname(SHORT_ABSOLUTE_NAME)
     end
 
-    names = Dnsruby::Resolv.getnames(IPV4_ADDR)
+    names = with_retries { Dnsruby::Resolv.getnames(IPV4_ADDR) }
     assert_equal(1, names.size)
-    assert_equal(RELATIVE_NAME, names.first.to_s)
-    Dnsruby::Resolv.each_name(IPV4_ADDR) { |name| assert_equal(RELATIVE_NAME, name.to_s)}
+    assert_equal(SHORT_ABSOLUTE_NAME, names.first.to_s(true))
+
+    found_names = with_retries(success_check: ->(_) { true }) do
+      names = []
+      Dnsruby::Resolv.each_name(IPV4_ADDR) { |name| names << name }
+      names
+    end
+
+    assert_equal(SHORT_ABSOLUTE_NAME, found_names.first.to_s(true))
   end
 
   def test_resolv_address_to_address

data/test/tc_resolver.rb

@@ -73,14 +73,26 @@ class TestResolver < Minitest::Test
   end
 
   def test_send_plain_message
-    resolver = Resolver.new
-    response, error = resolver.send_plain_message(Message.new("cnn.com"))
+    resolver = Resolver.new('1.1.1.1')
+
+    response, error = with_retries(success_check: ->((res, err)) { err.nil? || ! [Dnsruby::ServFail, Dnsruby::ResolvTimeout].include?(err.class) }) do
+      res, err = resolver.send_plain_message(Message.new("example.com", Types.A))
+      raise err if [Dnsruby::ServFail, Dnsruby::ResolvTimeout].include?(err.class)
+      [res, err]
+    end
+
     assert_nil_error(error)
     assert_valid_response(response)
 
     m = Message.new(BAD_DOMAIN_NAME)
     m.header.rd = true
-    response, error = resolver.send_plain_message(m)
+
+    response, error = with_retries(success_check: ->((res, err)) { err.class == Dnsruby::NXDomain || ! [Dnsruby::ServFail, Dnsruby::ResolvTimeout].include?(err.class) }) do
+      res, err = resolver.send_plain_message(m)
+      raise err if [Dnsruby::ServFail, Dnsruby::ResolvTimeout].include?(err.class)
+      [res, err]
+    end
+
     assert_valid_response(response)
     assert_error_is_exception(error, NXDomain)
   end
@@ -132,13 +144,13 @@ class TestResolver < Minitest::Test
     r = Resolver.new
     q=Queue.new
     r.send_async(m,q,q)
-    id,ret, error=q.pop
+    _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=~/google-public-dns/)
+        assert(answer.domainname.to_s=~/google/)
       end
     end
     assert(!no_pointer)
@@ -171,7 +183,7 @@ class TestResolver < Minitest::Test
     # 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/)
+    if (RUBY_PLATFORM !~ /darwin/)
       start=stop=0
       retry_times = 3
       retry_delay=1
@@ -185,14 +197,14 @@ class TestResolver < Minitest::Test
         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))
+        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.3 && time >= expected * 0.9, "Wrong time take, expected #{expected}, took #{time}")
       end
-  end
+    end
   end
 
   def test_packet_timeout
@@ -209,7 +221,7 @@ class TestResolver < Minitest::Test
         #  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))
+        res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
         fail
       rescue Dnsruby::ResolvTimeout
         stop=Time.now
@@ -227,7 +239,7 @@ class TestResolver < Minitest::Test
       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)
+      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)
@@ -284,8 +296,73 @@ class TestResolver < Minitest::Test
   def test_eventtype_api
     #  @TODO@ TEST THE Resolver::EventType interface!
   end
-end
 
+  def capture_sent_message(res, domain, pre_opt=nil)
+    q = Queue.new
+    res.send_async(Dnsruby::Message.new("test.invalid"), q)
+    q.pop
+    resolver_ruby = res.instance_variable_get("@resolver_ruby")
+    class << resolver_ruby
+      attr_accessor :message
+      alias_method :original_send_async, :send_async
+      def send_async(msg, client_queue, client_query_id=nil)
+        @message = msg
+        original_send_async(msg, client_queue, client_query_id)
+      end
+    end
+    msg = Dnsruby::Message.new(domain)
+    msg.add_additional(pre_opt) if pre_opt
+    res.send_async(msg, q)
+    _id, _response, _error = q.pop
+    resolver_ruby.message
+  end
+
+  def test_custom_udp_size
+    [false, true].each do |dnssec_setting|
+      [512, 513].each do |udp_size_setting|
+        res = Dnsruby::Resolver.new(:udp_size => udp_size_setting, :dnssec => dnssec_setting)
+        sent_msg = capture_sent_message(res, "example.com")
+
+        # The OPT RR is only present if the udp_size is > 512
+        opt = sent_msg.get_opt
+        if dnssec_setting
+          # DNSSEC overrides udp_size to 4096
+          assert(opt)
+          assert_equal(4096, opt.klass.code)
+        else
+          if udp_size_setting <= 512
+            assert_nil(opt)
+          else
+            assert(opt)
+            assert_equal(udp_size_setting, opt.klass.code)
+          end
+        end
+        if opt
+          assert_equal(0, opt.version)
+          assert_equal(0, opt.flags)
+        end
+      end
+    end
+  end
+
+  def test_no_duplicate_opt_when_pre_existing
+    [false, true].each do |dnssec_setting|
+      [512, 513].each do |udp_size_setting|
+        res = Dnsruby::Resolver.new(:udp_size => udp_size_setting, :dnssec => dnssec_setting)
+        pre_size = dnssec_setting ? 4096 : 1024
+        pre_opt = Dnsruby::RR::OPT.new(pre_size)
+        sent_msg = capture_sent_message(res, "example.com", pre_opt)
+
+        opt = sent_msg.get_opt
+        assert(opt)
+        assert_equal(1, sent_msg.additional.length) # No duplicate added
+        assert_equal(pre_size, opt.klass.code) # Original payload size unchanged
+        assert_equal(0, opt.version)
+        assert_equal(0, opt.flags) # Flags unchanged (code doesn't modify existing OPT)
+      end
+    end
+  end
+end
 
 # Tests to see that query_raw handles send_plain_message's return values correctly.
 class TestRawQuery < Minitest::Test
@@ -374,5 +451,31 @@ class TestRawQuery < Minitest::Test
     assert_equal KEY, options[:key]
     assert_equal ALGO, options[:algorithm]
   end
+  
+  def test_threads
+    resolver = Dnsruby::Resolver.new(nameserver: ["8.8.8.8", "8.8.4.4"])
+        resolver.query("google.com", "MX")
+         resolver.query("google.com", "MX")
+          resolver.query("google.com", "MX")
+          begin
+            resolver.query("googlöe.com", "MX") 
+          rescue Dnsruby::ResolvError
+            # fine
+          end
+          resolver.query("google.com", "MX")
+          resolver.query("google.com", "MX")
+          begin
+            resolver.query("googlöe.com", "MX")
+          rescue Dnsruby::ResolvError
+            # fine
+          end
+          begin
+            resolver.query("googlöe.com", "MX") 
+          rescue Dnsruby::ResolvError
+            # fine
+          end
+#          Dnsruby::Cache.delete("googlöe.com", "MX")
+          
+  end
 end
 

data/test/tc_rr-opt.rb

@@ -28,26 +28,29 @@ class TestRrOpt < Minitest::Test
   # This works only with send_plain_message, not send_message, query, etc.
   def test_plain_respects_bufsize
 
-    resolver = Resolver.new('a.gtld-servers.net')
+      resolver = Resolver.new('a.gtld-servers.net')
+      resolver.query_timeout=20
 
     run_test = ->(bufsize) do
 
+
       create_test_query = ->(bufsize) do
-        message = Message.new('com', Types.ANY, Classes.IN)
+        message = Message.new('com', Types.RRSIG, Classes.IN)
         message.add_additional(RR::OPT.new(bufsize))
         message
       end
 
       query = create_test_query.(bufsize)
       response, _error = resolver.send_plain_message(query)
-      # puts "\nBufsize is #{bufsize}, binary message size is #{response.encode.size}"
+      if (_error != nil) then
+        print "Error at #{bufsize} : #{_error}"
+      end
+#       puts "\nBufsize is #{bufsize}, binary message size is #{response.encode.size}"
       assert_equal(true, response.header.tc)
       assert(response.encode.size <= bufsize)
     end
 
-    run_test.(512)
     run_test.(612)
-    run_test.(4096)
   end
 
 

data/test/tc_rr-txt.rb

@@ -143,7 +143,13 @@ class TestRrTest < Minitest::Test
 
    r1 = RR.create("auto._domainkey.cacert.org.  43200 IN	TXT	\"v=DKIM1\;g=*\;k=rsa\;p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDDNFxiNr+NHJwih3OPhGr4iwLE+BBDu72YrMSzUnU1FF50CW7iOtuhg796UZ6xrZ5VuhAix6YmmzcvF2UxYzoD/XpfZ4MzBu0ND4/nkt9/YOTyIBzwQqn9uMNve0Y76Zsel89dIJtOI+y+lfnFExV0jKwe53gzmxMVpMSSCcZPGwIDAQAB\"	; ----- DKIM auto for cacert.org")
    r2 = RR.create("auto._domainkey.cacert.org.	43200	IN	TXT	\"v=DKIM1;g=*;k=rsa;p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDDNFxiNr+NHJwih3OPhGr4iwLE+BBDu72YrMSzUnU1FF50CW7iOtuhg796UZ6xrZ5VuhAix6YmmzcvF2UxYzoD/XpfZ4MzBu0ND4/nkt9/YOTyIBzwQqn9uMNve0Y76Zsel89dIJtOI+y+lfnFExV0jKwe53gzmxMVpMSSCcZPGwIDAQAB\"")
-   assert(r1.to_s == r2.to_s)
+   assert_equal(r1.to_s, r2.to_s)
+  end
+
+  def test_quote_and_unquoted
+    t = Dnsruby::RR::TXT.parse '"a" b'
+    assert_equal("a", t[0])
+    assert_equal("b", t[1])
   end
 
 end