dnsruby 1.70.0 → 1.74.0

data/lib/dnsruby/resource/NSEC.rb

@@ -152,7 +152,7 @@ module Dnsruby
       end
 
       def self.encode_types(nsec)
-        output = ''
+        output = +''
         # types represents all 65536 possible RR types.
         # Split up types into sets of 256 different types.
         type_codes = []
@@ -171,7 +171,7 @@ module Dnsruby
 
           unless types_to_go.empty?
             #  Then create the bitmap for them
-            bitmap = ''
+            bitmap = +''
             #  keep on adding them until there's none left
             pos = 0
             bitmap_pos = 0

data/lib/dnsruby/resource/NXT.rb

@@ -95,7 +95,7 @@ class NXT < RR
     next_domain = Name.create(next_domain) if next_domain.is_a?(String)
     types = TypeBitmap.from_type_codes(types) if types.is_a?(Array)
 
-    binary_string = ''.force_encoding('ASCII-8BIT')
+    binary_string = ''.b
     binary_string << next_domain.canonical
     binary_string << BitMapping.reverse_binary_string_bits(types.to_binary_string)
     binary_string

data/lib/dnsruby/resource/OPT.rb

@@ -227,13 +227,12 @@ module Dnsruby
         if @options
           @options.each do |opt|
             if opt.code == EDNS_SUBNET_OPTION
-              ret = ret + "CLIENT-SUBNET: #{get_client_subnet(opt)}"
+              ret = ret + "CLIENT-SUBNET: #{get_client_subnet(opt)}\n"
             else
-              ret = ret + " " + opt.to_s
+              ret = ret + "OPT=#{opt.code}: #{opt.data}\n"
             end
           end
         end
-        ret = ret + "\n"
         return ret
       end
 

data/lib/dnsruby/resource/TXT.rb

@@ -63,7 +63,7 @@ module Dnsruby
         unquoted = false
         seen_strings = false
         pos = 0
-        input.sub!(/^\s*\(\s*/, "")
+        input = input.sub(/^\s*\(\s*/, "")
         input.sub!(/\s*\)\s*$/, "")
         input.each_char {|c|
           if (((c == "'") || (c == '"')) && (!in_escaped) && (!unquoted))

data/lib/dnsruby/select_thread.rb

@@ -138,6 +138,10 @@ module Dnsruby
         @@sockets << query_settings.socket
         @@socket_is_persistent[query_settings.socket] = query_settings.is_persistent_socket
       }
+      wake_up_select_thread
+    end
+
+    def wake_up_select_thread
       begin
         @@wakeup_sockets[0].send("wakeup!", 0)
       rescue Exception
@@ -224,17 +228,20 @@ module Dnsruby
           if (unused_loop_count > 10 && @@query_hash.empty? && @@observers.empty?)
             Dnsruby.log.debug("Try stop select loop")
 
+            # We leave the @@wakeup_sockets here, but remove everything else
             non_persistent_sockets = @@sockets.select { |s| ! @@socket_is_persistent[s] }
             non_persistent_sockets.each do |socket|
-              socket.close rescue nil
-              @@sockets.delete(socket)
+              if socket != @@wakeup_sockets[1]
+                socket.close rescue nil
+                @@sockets.delete(socket)
+              end
             end
 
-            Dnsruby.log.debug("Deleted #{non_persistent_sockets.size} non-persistent sockets," +
-                              " #{@@sockets.count} persistent sockets remain.")
+            Dnsruby.log.debug("Deleted #{non_persistent_sockets.size - 1} non-persistent sockets," +
+                              " #{@@sockets.count - 1} persistent sockets remain.")
             @@socket_hash.clear
 
-            if @@sockets.empty?
+            if @@sockets.size == 1
               Dnsruby.log.debug("Stopping select loop")
               return
             end
@@ -247,10 +254,11 @@ module Dnsruby
     # Removes closed sockets from @@sockets, and returns an array containing 1
     # exception for each closed socket contained in @@socket_hash.
     def clean_up_closed_sockets
+      exceptions = []
       @@mutex.synchronize do
         closed_sockets_in_hash = @@sockets.select(&:closed?).select { |s| @@socket_hash[s] }
         @@sockets.delete_if { | socket | socket.closed? }
-        closed_sockets_in_hash.each_with_object([]) do |socket, exceptions|
+        closed_sockets_in_hash.each_with_object([]) do |socket, exception|
           @@socket_hash[socket].each do | client_id |
             exceptions << [SocketEofResolvError.new("TCP socket closed before all answers received"), socket, client_id]
           end
@@ -368,21 +376,28 @@ module Dnsruby
     end
 
     def remove_id(id)
-
       @@mutex.synchronize do
-        socket = @@query_hash[id].socket
-        @@timeouts.delete(id)
-        @@query_hash.delete(id)
-        @@socket_hash[socket].delete(id)
-
-        decrement_remaining_queries(socket) if persistent?(socket)
-
-        if !persistent?(socket) || max_attained?(socket)
-          @@sockets.delete(socket)
-          @@socket_hash.delete(socket)
-          Dnsruby.log.debug("Closing socket #{socket}")
-          socket.close rescue nil
-        end
+        remove_id_from_mutex_synchronized_block(id)
+      end
+    end
+
+    # THIS MUST BE CALLED FROM INSIDE A @@mutex SYNCHRONISED BLOCK!
+    def remove_id_from_mutex_synchronized_block(id)
+      socket = @@query_hash[id].socket
+      @@timeouts.delete(id)
+      @@query_hash.delete(id)
+      @@socket_hash[socket].delete(id)
+
+      decrement_remaining_queries(socket) if persistent?(socket)
+
+      if !persistent?(socket) || max_attained?(socket)
+        @@sockets.delete(socket)
+        @@socket_hash.delete(socket)
+        @@socket_remaining_queries.delete(socket)
+        @@socket_is_persistent.delete(socket)
+        @@tcp_buffers.delete(socket)
+        Dnsruby.log.debug("Closing socket #{socket}")
+        socket.close rescue nil
       end
     end
 
@@ -414,12 +429,12 @@ module Dnsruby
       #  Keep buffer for all TCP sockets, and return
       #  to select after reading available data. Once all data has been received,
       #  then process message.
-      buf=""
+      buf = +""
       expected_length = 0
       @@mutex.synchronize {
         buf, expected_length = @@tcp_buffers[socket]
         if (!buf)
-          buf = ""
+          buf = +""
           expected_length = 2
           @@tcp_buffers[socket]=[buf, expected_length]
         end
@@ -443,7 +458,7 @@ module Dnsruby
 
             return false
           end
-          buf << input
+          buf << input if input
         rescue
           #  Oh well - better luck next time!
           return false
@@ -455,7 +470,7 @@ module Dnsruby
           #  We just read the data_length field. Now we need to start reading that many bytes.
           @@mutex.synchronize {
             answersize = buf.unpack('n')[0]
-            @@tcp_buffers[socket] = ["", answersize]
+            @@tcp_buffers[socket] = [+"", answersize]
           }
           return tcp_read(socket)
         else
@@ -546,12 +561,10 @@ module Dnsruby
               query_header_id = @@query_hash[id].query.header.id
               if (query_header_id == e.partial_message.header.id)
                 #  process the response
-                client_queue = nil
-                res = nil
-                query=nil
                 client_queue = @@query_hash[id].client_queue
                 res = @@query_hash[id].single_resolver
                 query = @@query_hash[id].query
+                remove_id_from_mutex_synchronized_block(id)
 
                 #  NOW RESEND OVER TCP!
                 Thread.new {
@@ -641,6 +654,7 @@ module Dnsruby
           do_select
         }
       end
+      wake_up_select_thread
     end
 
     def push_response_to_select(client_id, client_queue, msg, query, res)
@@ -661,6 +675,7 @@ module Dnsruby
           do_select
         }
       end
+      wake_up_select_thread
     end
 
     def push_validation_response_to_select(client_id, client_queue, msg, err, query, res)
@@ -677,6 +692,7 @@ module Dnsruby
           do_select
         }
       end
+      wake_up_select_thread
     end
 
     def send_queued_exceptions

data/lib/dnsruby/single_verifier.rb

@@ -773,7 +773,7 @@ module Dnsruby
         }.to_s # @TODO@ worry about wildcards here?
         rec.ttl = old_ttl
         if (RUBY_VERSION >= "1.9")
-          data.force_encoding("ASCII-8BIT")
+          data.force_encoding(Encoding::BINARY)
         end
         sig_data += data
       end

data/lib/dnsruby/version.rb

@@ -1,3 +1,3 @@
 module Dnsruby
-  VERSION = '1.70.0'
+  VERSION = '1.74.0'
 end

data/test/spec_helper.rb

@@ -5,8 +5,12 @@ if Warning.respond_to?(:[]=)
 end
 
 if ENV['RUN_EXTRA_TASK'] == 'TRUE'
-  require 'coveralls'
-  Coveralls.wear!
+  unless "test".frozen?
+    # Coverall setup term-ansi-color which isn't yet frozen string literal compatible
+    # Ref: https://github.com/flori/term-ansicolor/pull/38
+    require 'coveralls'
+    Coveralls.wear!
+  end
 
   require 'simplecov'
 
@@ -22,7 +26,7 @@ require 'minitest'
 require 'minitest/autorun'
 require 'minitest/display'
 
-MiniTest::Display.options = {
+Minitest::Display.options = {
   suite_names: true,
   color: true,
   print: {
@@ -39,3 +43,18 @@ MiniTest::Display.options = {
   require_relative '../lib/dnsruby'
   require_relative 'test_utils'
 end.()
+
+def with_retries(max_attempts: 5, exceptions: [Dnsruby::ServFail, Dnsruby::ResolvTimeout], success_check: ->(result) { result }, &block)
+  attempts = 0
+  while attempts < max_attempts
+    begin
+      result = block.call
+      return result if success_check.call(result)  # e.g., for nil-check: ->(r) { r }
+    rescue *exceptions => e
+      puts "Retry #{attempts + 1}/#{max_attempts}: #{e.class} - #{e.message}" if ENV['DEBUG_TESTS']
+    end
+    sleep(1)
+    attempts += 1
+  end
+  raise Minitest::Assertion, "Failed after #{max_attempts} retries"
+end

data/test/tc_caa.rb

@@ -25,6 +25,8 @@ class TestCAA < Minitest::Test
     {'foo.com. IN CAA 0 issue "ca.example.net"' => [0, 'issue', 'ca.example.net'],
      'foo.com. IN CAA 1 issue "ca.example.net"' => [1, 'issue', 'ca.example.net'],
      'foo.com. IN CAA 0 issuewild "ca.example.net"' => [0, 'issuewild', 'ca.example.net'],
+     'foo.com. IN CAA 0 issuemail "ca.example.net"' => [0, 'issuemail', 'ca.example.net'],
+     'foo.com. IN CAA 0 issuevmc "ca.example.net"' => [0, 'issuevmc', 'ca.example.net'],
      'foo.com. IN CAA 0 iodef "mailto:security@example.com"' => [0, 'iodef', 'mailto:security@example.com'],
      'foo.com. IN CAA 0 issue "ca.example.net; account=230123"' => [0, 'issue', 'ca.example.net; account=230123']
     }.each do |text, data|
@@ -44,5 +46,16 @@ class TestCAA < Minitest::Test
     end
   end
 
+  def test_caa_error
+    {
+      'foo.com. IN CAA 0 ca.example.net "issue"' => [0, 'ca.example.net', 'issue'],
+      'foo.com. IN CAA 0 Issue "ca.example.net"' => [0, 'Issue', 'ca.example.net']
+    }.each do |text, data|
+      assert_raises DecodeError do
+        RR.create(text)
+      end
+    end
+  end
+
 end
 

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)
 
@@ -249,14 +249,14 @@ class TestDNS < Minitest::Test
     end
   end
 
-    def test_port
-      d = DNS.new({:port => 5353})
-      assert(d.to_s.include?"5353")
-    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
+  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_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_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,11 +2,6 @@ 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.

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

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_res_config.rb

@@ -92,4 +92,33 @@ class TestResolverConfig < Minitest::Test
     end;
   end
 
+  def test_bad_ns
+    begin
+      res = Dnsruby::Resolver.new(:nameserver => ["ns32.domiancontrol.com."])
+      res.query("example.com")
+      assert(false, "Should not query with bad nameserver")
+    rescue Exception => e
+      # OK
+    end
+  end
+
+  def test_bad_ns_post_init
+    begin
+      resolver = Dnsruby::Resolver.new(recurse: false, do_caching: false, retry_times: 2)
+      resolver.nameserver = ["ns32.domiancontrol.com."]
+      assert(false, "Should not allow bad nameserver")
+      resolver.query("example.com")
+    rescue ArgumentError
+    end
+  end
+
+  def test_one_good_ns_rest_bad
+    begin
+      resolver = Dnsruby::Resolver.new(recurse: false, do_caching: false, retry_times: 2)
+      resolver.nameserver = ["ns32.domiancontrol.com.", "1.1.1.1"]
+      resolver.query("example.com")
+    rescue ArgumentError
+      assert(false, "Should allow one good nameserver")
+    end
+  end
 end

data/test/tc_resolv.rb

@@ -51,19 +51,26 @@ class TestResolv < Minitest::Test
     end
   end
 
-
   def test_resolv_address_to_name
 
-    assert_equal(SHORT_ABSOLUTE_NAME, Dnsruby::Resolv.getname(IPV4_ADDR).to_s(true))
+    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(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(SHORT_ABSOLUTE_NAME, names.first.to_s(true))
-    Dnsruby::Resolv.each_name(IPV4_ADDR) { |name| assert_equal(SHORT_ABSOLUTE_NAME, name.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