dnsruby 1.55 → 1.56.0

data/test/tc_hash.rb

@@ -1,30 +1,26 @@
-#--
-#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
-#
+# --
+# 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
+# 
+# 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 'test/unit'
 require 'set'
-require 'dnsruby'
 
 module Dnsruby
 
-class TestHash < Test::Unit::TestCase
+class TestHash < Minitest::Test
 
   def test_types_hash
     object1 = Types.new(Types::NSEC3)

data/test/tc_header.rb

@@ -1,53 +1,50 @@
-#--
-#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 TestHeader < Test::Unit::TestCase
+class TestHeader < Minitest::Test
   def test_header
     header = Header.new();
     assert(header, "new() returned something")
-    
+
     header.id=41
     assert_equal(header.id, 41, "id() works")
-    
+
     header.qr=true
     assert_equal(header.qr, true, "qr() works")
-    
+
     header.opcode="QUERY"
-    assert_equal(OpCode.Query, header.opcode, 
+    assert_equal(OpCode.Query, header.opcode,
                       "opcode() works")
     header.opcode=OpCode::Query
-    assert_equal(header.opcode.string, "Query", 
+    assert_equal(header.opcode.string, "Query",
                       "opcode() works")
-    
-    
+
+
     header.aa=true
     assert_equal(header.aa, true, "aa() works")
-    
+
     header.tc=false
     assert_equal(header.tc, false, "tc() works")
-    
+
     header.rd=true
     assert_equal(header.rd, true, "rd() works")
-    
+
     header.ad=true
     assert_equal(header.ad, true, "rd() works")
 
@@ -56,52 +53,46 @@ class TestHeader < Test::Unit::TestCase
 
     header.ra=true
     assert_equal(header.ra, true, "ra() works")
-    
+
     header.qr=true
     assert_equal(header.qr, true, "qr() works")
-    
+
     header.rcode="NOERROR"
     assert_equal(header.get_header_rcode, RCode::NOERROR, "rcode() works")
     header.rcode=RCode.NOERROR
     assert_equal(header.get_header_rcode.string, "NOERROR", "rcode() works")
-    
+
     header.qdcount=1
     header.ancount=2
     header.nscount=3
     header.arcount=3
-    
-    
-    # Reenable when support for CD is there
-    #header.cd=0
-    #assert_equal(header.cd, 0, "cd() works")
+
+
+    #  Reenable when support for CD is there
+    # header.cd=0
+    # assert_equal(header.cd, 0, "cd() works")
     data = header.data
-    
+
     header2 = Header.new_from_data(data);
-    
+
     assert(header==(header2), 'Headers are the same');
-    
-    #
-    #  Is header.inspect remotely sane?
-    #
-    assert(header.to_s =~ /opcode = Query/, 'inspect() has opcode correct');
-    assert(header.to_s =~ /ancount = 2/,    'inspect() has ancount correct');
-    
+
     header = Header.new;
-    
-    #
-    # Check that the aliases work properly.
-    #
+
+    # 
+    #  Check that the aliases work properly.
+    # 
     header.zocount=(0);
     header.prcount=(1);
     header.upcount=(2);
     header.adcount=(3);
-    
+
     assert_equal(header.zocount, 0, 'zocount works');
     assert_equal(header.prcount, 1, 'prcount works');
     assert_equal(header.upcount, 2, 'upcount works');
     assert_equal(header.adcount, 3, 'adcount works');
-    
-    
-    
+
+
+
   end
 end

data/test/tc_hip.rb

@@ -1,27 +1,24 @@
 
-#--
-#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
-#
+# --
+# 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'
+# 
+# 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 TestHIP < Test::Unit::TestCase
+class TestHIP < Minitest::Test
   def test_hip
     [{"www.example.com.      IN  HIP ( 2 200100107B1A74DF365639CC39F1D578
                                 AwEAAbdxyhNuSutc5EMzxTs9LBPCIkOFH8cIvM4p9+LrV4e19WzK00+CI6zBCQTdtWsuxKbWIy87UOoJTwkUs7lBu+Upr1gsNrut79ryra+bSRGQb1slImA8YVJyuIDsj7kwzG7jnERNqnWxZ48AWkskmdHaVDP4BcelrTI3rMXdXF5D )" =>
@@ -70,4 +67,4 @@ class TestHIP < Test::Unit::TestCase
   end
 
 end
- 
+

data/test/tc_ipseckey.rb

@@ -1,27 +1,24 @@
 
-#--
-#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
-#
+# --
+# 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'
+# 
+# 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 TestIPSECKEY < Test::Unit::TestCase
+class TestIPSECKEY < Minitest::Test
   def test_ipseckey
     [{"38.1.0.192.in-addr.arpa. 7200 IN     IPSECKEY ( 10 3 2
                     mygateway.example.com.

data/test/tc_keith.rb

@@ -0,0 +1,300 @@
+# --
+# 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 tmexpress or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+require_relative 'spec_helper'
+
+require 'socket'
+
+include Dnsruby
+# @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 TestResolver < Minitest::Test
+
+  include Dnsruby
+
+  Thread::abort_on_exception = true
+
+  GOOD_DOMAIN_NAME = 'example.com'
+  BAD_DOMAIN_NAME  = 'dnsruby-test-of-bad-domain-name.blah'
+
+  PORT = 42138
+  @@port = PORT
+
+  def setup
+    Dnsruby::Config.reset
+  end
+
+  def assert_valid_response(response)
+    assert(response.kind_of?(Message), "Expected response to be a message but was a #{response.class}")
+  end
+
+  def assert_nil_response(response)
+    assert(response.nil?, "Expected no response but got a #{response.class}:\n#{response}")
+  end
+
+  def assert_error_is_exception(error, error_class = Exception)
+    assert(error.is_a?(error_class), "Expected error to be an #{error_class}, but was a #{error.class}:\n#{error}")
+  end
+
+  def assert_nil_error(error)
+    assert(error.nil?, "Expected no error but got a #{error.class}:\n#{error}")
+  end
+
+  def test_send_message
+    response = Resolver.new.send_message(Message.new("example.com", Types.A))
+    assert_valid_response(response)
+  end
+
+  def test_send_message_bang_noerror
+    response, error = Resolver.new.send_message!(Message.new(GOOD_DOMAIN_NAME, Types.A))
+    assert_nil_error(error)
+    assert_valid_response(response)
+  end
+
+  def test_send_message_bang_error
+    message = Message.new(BAD_DOMAIN_NAME, Types.A)
+    response, error = Resolver.new.send_message!(message)
+    assert_nil_response(response)
+    assert_error_is_exception(error)
+  end
+
+  def test_send_plain_message
+    resolver = Resolver.new
+    response, error = resolver.send_plain_message(Message.new("cnn.com"))
+    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)
+    assert_valid_response(response)
+    assert_error_is_exception(error, NXDomain)
+  end
+
+  def test_query
+    response = Resolver.new.query("example.com")
+    assert_valid_response(response)
+  end
+
+  def test_query_bang_noerror
+    response, error = Resolver.new.query!(GOOD_DOMAIN_NAME)
+    assert_nil_error(error)
+    assert_valid_response(response)
+  end
+
+  def test_query_bang_error
+    response, error = Resolver.new.query!(BAD_DOMAIN_NAME)
+    assert_nil_response(response)
+    assert_error_is_exception(error)
+  end
+
+  def test_query_async
+    q = Queue.new
+    Resolver.new.send_async(Message.new("example.com", Types.A),q,q)
+    id, response, error = q.pop
+    assert_equal(id, q, "Id wrong!")
+    assert_valid_response(response)
+    assert_nil_error(error)
+  end
+
+  def test_query_one_duff_server_one_good
+    res = Resolver.new({:nameserver => ["8.8.8.8", "8.8.8.7"]})
+    res.retry_delay=1
+    q = Queue.new
+    res.send_async(Message.new("example.com", Types.A),q,q)
+    id, response, error = q.pop
+    assert_equal(id, q, "Id wrong!")
+    assert_valid_response(response)
+    assert_nil_error(error)
+  end
+
+  #  @TODO@ Implement!!  But then, why would anyone want to do this?
+  #   def test_many_threaded_clients
+  #     assert(false, "IMPLEMENT!")
+  #   end
+
+  def test_reverse_lookup
+    m = Message.new("8.8.8.8", Types.PTR)
+    r = Resolver.new
+    q=Queue.new
+    r.send_async(m,q,q)
+    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/)
+      end
+    end
+    assert(!no_pointer)
+  end
+
+#  def test_bad_host
+#    res = Resolver.new({:nameserver => "localhost"})
+#    res.retry_times=1
+#    res.retry_delay=0
+#    res.query_timeout = 1
+#    q = Queue.new
+#    res.send_async(Message.new("example.com", Types.A), q, q)
+#    id, m, err = q.pop
+#    assert(id==q)
+#    assert(m == nil)
+#    assert(err.kind_of?(OtherResolvError) || err.kind_of?(IOError), "OtherResolvError or IOError expected : got #{err.class}")
+#  end
+# 
+  def test_nxdomain
+    resolver = Resolver.new
+    q = Queue.new
+    resolver .send_async(Message.new(BAD_DOMAIN_NAME, Types.A), q, 1)
+    id, m, error = q.pop
+    assert(id==1, "Id should have been 1 but was #{id}")
+    assert(m.rcode == RCode.NXDOMAIN, "Expected NXDOMAIN but got #{m.rcode} instead.")
+    assert_error_is_exception(error, NXDomain)
+  end
+
+  def test_timeouts
+    # 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/)
+      start=stop=0
+      retry_times = 3
+      retry_delay=1
+      packet_timeout=2
+      #  Work out what time should be, then time it to check
+      expected = ((2**(retry_times-1))*retry_delay) + packet_timeout
+      begin
+        res = Resolver.new({:nameserver => "10.0.1.128"})
+        #       res = Resolver.new({:nameserver => "213.248.199.17"})
+        res.packet_timeout=packet_timeout
+        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))
+        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
+
+  def test_packet_timeout
+        res = Resolver.new({:nameserver => []})
+#      res = Resolver.new({:nameserver => "10.0.1.128"})
+      start=stop=0
+      retry_times = retry_delay = packet_timeout= 10
+      query_timeout=2
+      begin
+        res.packet_timeout=packet_timeout
+        res.retry_times=retry_times
+        res.retry_delay=retry_delay
+        res.query_timeout=query_timeout
+        #  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))
+        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
+
+  def test_queue_packet_timeout
+#    if (!RUBY_PLATFORM=~/darwin/)
+      res = Resolver.new({:nameserver => "10.0.1.128"})
+#      bad = SingleResolver.new("localhost")
+      res.add_server("localhost")
+      expected = 2
+      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)
+      id,ret,err = q.pop
+      stop = Time.now
+      assert(id=q)
+      assert(ret==nil)
+      assert(err.class == ResolvTimeout, "#{err.class}, #{err}")
+      time = stop-start
+      assert(time <= expected *1.3 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")
+#    end
+  end
+
+  def test_illegal_src_port
+    #  Also test all singleresolver ports ok
+    #  Try to set src_port to an illegal value - make sure error raised, and port OK
+    res = Resolver.new
+    res.port = 56789
+    tests = [53, 387, 1265, 3210, 48619]
+    tests.each do |bad_port|
+      begin
+        res.src_port = bad_port
+        fail("bad port #{bad_port}")
+      rescue
+      end
+    end
+    assert(res.single_resolvers[0].src_port = 56789)
+  end
+
+  def test_add_src_port
+    #  Try setting and adding port ranges, and invalid ports, and 0.
+    #  Also test all singleresolver ports ok
+    res = Resolver.new
+    res.src_port = [56789,56790, 56793]
+    assert(res.src_port == [56789,56790, 56793])
+    res.src_port = 56889..56891
+    assert(res.src_port == [56889,56890,56891])
+    res.add_src_port(60000..60002)
+    assert(res.src_port == [56889,56890,56891,60000,60001,60002])
+    res.add_src_port([60004,60005])
+    assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005])
+    res.add_src_port(60006)
+    assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])
+    #  Now test invalid src_ports
+    tests = [0, 53, [60007, 53], [60008, 0], 55..100]
+    tests.each do |x|
+      begin
+        res.add_src_port(x)
+        fail()
+      rescue
+      end
+    end
+    assert(res.src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])
+    assert(res.single_resolvers[0].src_port == [56889,56890,56891,60000,60001,60002,60004,60005,60006])
+  end
+
+  def test_eventtype_api
+    #  @TODO@ TEST THE Resolver::EventType interface!
+  end
+
+  def test_rd_not_overwritten
+    message = Message.new(GOOD_DOMAIN_NAME)
+    message.header.rd = false
+    assert(! message.header.rd)
+    resolver = Resolver.new
+    raise "Header rd flag was overwritten to true in #{__FILE__}:#{__LINE__}" if message.header.rd
+    _response = resolver.send_message(message)
+    puts "Header rd: #{message.header.rd}"
+    raise "Header rd flag was overwritten to true in #{__FILE__}:#{__LINE__}" if message.header.rd
+    assert(! message.header.rd, "Header rd flag was overwritten to true")
+  end
+end