net-dns 0.6.1 → 0.7.0

data/test/names_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+require 'net/dns/names'
+
+class NamesTest < Test::Unit::TestCase
+  include Net::DNS::Names
+
+  def test_long_names
+    assert_nothing_raised do
+      pack_name('a' * 63)
+    end
+    assert_raises ArgumentError do
+      pack_name('a' * 64)
+    end
+    assert_nothing_raised do
+      pack_name(['a' * 63, 'b' * 63, 'c' * 63, 'd' * 63].join('.'))
+    end
+    assert_raises ArgumentError do
+      pack_name(['a' * 63, 'b' * 63, 'c' * 63, 'd' * 63, 'e'].join('.'))
+    end
+  end
+end

data/test/packet_test.rb

@@ -2,41 +2,48 @@ require 'test_helper'
 require 'net/dns/packet'
 
 class PacketTest < Test::Unit::TestCase
-  include Net::DNS
 
   def setup
+    @klass  = Net::DNS::Packet
     @domain = 'example.com'
-    @type   = 'MX'
-    @cls  = 'HS'
-     
-    @default = Packet.new(@domain)
-    @string = Packet.new(@domain, MX, HS)
-    
-    packet = "\337M\201\200\000\001\000\003\000\004\000\004\006google\003com\000\000\001\000\001\300\f\000\001\000\001\000\000\001,\000\004@\351\273c\300\f\000\001\000\001\000\000\001,\000\004H\016\317c\300\f\000\001\000\001\000\000\001,\000\004@\351\247c\300\f\000\002\000\001\000\003\364\200\000\006\003ns1\300\f\300\f\000\002\000\001\000\003\364\200\000\006\003ns2\300\f\300\f\000\002\000\001\000\003\364\200\000\006\003ns3\300\f\300\f\000\002\000\001\000\003\364\200\000\006\003ns4\300\f\300X\000\001\000\001\000\003\307\273\000\004\330\357 \n\300j\000\001\000\001\000\003\307\273\000\004\330\357\"\n\300|\000\001\000\001\000\003\307\273\000\004\330\357$\n\300\216\000\001\000\001\000\003\307\273\000\004\330\357&\n"
-    
-    @binary = Packet.parse(packet)
-    
   end
-  
-  def test_instances
-    assert_instance_of(Net::DNS::Packet, @string)
-    assert_instance_of(Net::DNS::Header, @string.header)
-    assert_instance_of(Array, @string.question)
-    assert_instance_of(Net::DNS::Question, @string.question[0])
-    assert_instance_of(Array, @string.answer)
-    assert_instance_of(Array, @string.authority)
-    assert_instance_of(Array, @string.additional)    
 
-    assert_instance_of(Net::DNS::Packet, @binary)    
-    assert_instance_of(Net::DNS::Header, @binary.header)
-    assert_instance_of(Array, @binary.question)
-    assert_instance_of(Net::DNS::Question, @binary.question[0])
-    assert_instance_of(Array, @binary.answer)
-    assert_instance_of(Net::DNS::RR::A, @binary.answer[0])
-    assert_instance_of(Array, @binary.authority)
-    assert_instance_of(Net::DNS::RR::NS, @binary.authority[0])
-    assert_instance_of(Array, @binary.additional)    
-    assert_instance_of(Net::DNS::RR::A, @binary.additional[0])    
+  def test_initialize
+    @record = @klass.new(@domain, Net::DNS::MX, Net::DNS::HS)
+    assert_instance_of @klass,              @record
+    assert_instance_of Net::DNS::Header,    @record.header
+    assert_instance_of Array,               @record.question
+    assert_instance_of Net::DNS::Question,  @record.question.first
+    assert_instance_of Array,               @record.answer
+    assert_instance_of Array,               @record.authority
+    assert_instance_of Array,               @record.additional
+  end
+
+  def test_initialize_should_set_question
+    @question = @klass.new(@domain).question.first
+    assert_equal @domain, @question.qName
+    assert_equal Net::DNS::RR::Types.new(Net::DNS::A).to_s, @question.qType.to_s
+    assert_equal Net::DNS::RR::Classes.new(Net::DNS::IN).to_s, @question.qClass.to_s 
+
+    @question = @klass.new(@domain, Net::DNS::MX, Net::DNS::HS).question.first
+    assert_equal @domain, @question.qName
+    assert_equal Net::DNS::RR::Types.new(Net::DNS::MX).to_s, @question.qType.to_s
+    assert_equal Net::DNS::RR::Classes.new(Net::DNS::HS).to_s, @question.qClass.to_s
+  end
+
+  def test_self_parse
+    packet = "\337M\201\200\000\001\000\003\000\004\000\004\006google\003com\000\000\001\000\001\300\f\000\001\000\001\000\000\001,\000\004@\351\273c\300\f\000\001\000\001\000\000\001,\000\004H\016\317c\300\f\000\001\000\001\000\000\001,\000\004@\351\247c\300\f\000\002\000\001\000\003\364\200\000\006\003ns1\300\f\300\f\000\002\000\001\000\003\364\200\000\006\003ns2\300\f\300\f\000\002\000\001\000\003\364\200\000\006\003ns3\300\f\300\f\000\002\000\001\000\003\364\200\000\006\003ns4\300\f\300X\000\001\000\001\000\003\307\273\000\004\330\357 \n\300j\000\001\000\001\000\003\307\273\000\004\330\357\"\n\300|\000\001\000\001\000\003\307\273\000\004\330\357$\n\300\216\000\001\000\001\000\003\307\273\000\004\330\357&\n"
+    @record = @klass.parse(packet)
+    assert_instance_of @klass,              @record
+    assert_instance_of Net::DNS::Header,    @record.header
+    assert_instance_of Array,               @record.question
+    assert_instance_of Net::DNS::Question,  @record.question.first
+    assert_instance_of Array,               @record.answer
+    assert_instance_of Net::DNS::RR::A,     @record.answer.first
+    assert_instance_of Array,               @record.authority
+    assert_instance_of Net::DNS::RR::NS,    @record.authority.first
+    assert_instance_of Array,               @record.additional
+    assert_instance_of Net::DNS::RR::A,     @record.additional.first
   end
-  
+
 end    

data/test/question_test.rb

@@ -2,20 +2,19 @@ require 'test_helper'
 require 'net/dns/question'
 
 class QuestionTest < Test::Unit::TestCase
-  include Net::DNS
 
   def setup
     @domain = 'example.com.'
     @type   = 'MX'
     @cls  = 'HS'
     @data = "\006google\003com\000\000\001\000\001"
-    
-    @default = Question.new(@domain)
-    @string  = Question.new(@domain,@type,@cls)
-    @binary  = Question.parse(@data)
-    @binary2 = Question.parse(@string.data)
+
+    @default = Net::DNS::Question.new(@domain)
+    @string  = Net::DNS::Question.new(@domain,@type,@cls)
+    @binary  = Net::DNS::Question.parse(@data)
+    @binary2 = Net::DNS::Question.parse(@string.data)
   end
-  
+
   def test_simple
     assert_equal(@default.qName, @domain)
     assert_equal(@default.qType.to_s, "A")
@@ -24,31 +23,31 @@ class QuestionTest < Test::Unit::TestCase
     assert_equal(@string.qName, @domain)
     assert_equal(@string.qType.to_s, "MX")
     assert_equal(@string.qClass.to_s, "HS")
-    
+
     assert_equal(@binary.qName, "google.com.")
     assert_equal(@binary.qType.to_s, "A")
     assert_equal(@binary.qClass.to_s, "IN")
-    
+
     assert_equal(@binary2.qName, @domain)
     assert_equal(@binary2.qType.to_s, "MX")
     assert_equal(@binary2.qClass.to_s, "HS")
   end
 
   def test_raise
-    assert_raise(Net::DNS::Question::NameError) do
-      Question.new(1)
-    end
-    assert_raise(Net::DNS::Question::NameError) do
-      Question.new("test{")
+    # assert_raises(Net::DNS::Question::NameInvalid) do
+    #   Net::DNS::Question.new(1)
+    # end
+    assert_raises(Net::DNS::Question::NameInvalid) do
+      Net::DNS::Question.new("test{")
     end
-    assert_raise(Net::DNS::Question::ArgumentError) do
-      Question.parse(Array.new)
+    assert_raises(ArgumentError) do
+      Net::DNS::Question.parse(Array.new)
     end
-    assert_raise(Net::DNS::Question::ArgumentError) do
-      Question.parse("test")
+    assert_raises(ArgumentError) do
+      Net::DNS::Question.parse("test")
     end
   end
-  
+
   def test_inspect
     assert_equal  "google.com.                  IN      A       ",
                   Net::DNS::Question.new("google.com.").inspect
@@ -59,12 +58,12 @@ class QuestionTest < Test::Unit::TestCase
     assert_equal  "google.com.                  IN      NS      ",
                   Net::DNS::Question.new("google.com.", Net::DNS::NS).inspect
   end
-  
+
   def test_inspect_with_name_longer_than_29_chrs
     assert_equal  "supercalifragilistichespiralidoso.com IN      A       ",
                   Net::DNS::Question.new("supercalifragilistichespiralidoso.com").inspect
   end
-  
+
   def test_to_s
     assert_equal  "google.com.                  IN      A       ",
                   Net::DNS::Question.new("google.com.").to_s
@@ -75,10 +74,10 @@ class QuestionTest < Test::Unit::TestCase
     assert_equal  "google.com.                  IN      NS      ",
                   Net::DNS::Question.new("google.com.", Net::DNS::NS).to_s
   end
-  
+
   def test_to_s_with_name_longer_than_29_chrs
     assert_equal  "supercalifragilistichespiralidoso.com IN      A       ",
                   Net::DNS::Question.new("supercalifragilistichespiralidoso.com").to_s
   end
-  
-end    
+
+end

data/test/resolver/timeouts_test.rb

@@ -18,10 +18,10 @@ class DnsTimeoutTest < Test::Unit::TestCase
   end
 
   def test_initialize_should_set_raise_with_invalid_timeout
-    assert_raise(ArgumentError) { @klass.new(nil) }
-    assert_raise(ArgumentError) { @klass.new("") }
-    assert_raise(ArgumentError) { @klass.new("foo") }
-    assert_raise(ArgumentError) { @klass.new(-1) }
+    assert_raises(ArgumentError) { @klass.new(nil) }
+    assert_raises(ArgumentError) { @klass.new("") }
+    assert_raises(ArgumentError) { @klass.new("foo") }
+    assert_raises(ArgumentError) { @klass.new(-1) }
   end
 
 
@@ -33,7 +33,7 @@ class DnsTimeoutTest < Test::Unit::TestCase
 
 
   def test_timeout_should_raise_localjumperror_without_block
-    assert_raise(LocalJumpError) { @klass.new(1).timeout }
+    assert_raises(LocalJumpError) { @klass.new(1).timeout }
   end
 
 end
@@ -41,13 +41,13 @@ end
 class TcpTimeoutTest < Test::Unit::TestCase
 
   def test_initialize
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       Net::DNS::Resolver::TcpTimeout.new("a")
     end
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       Net::DNS::Resolver::TcpTimeout.new(-1)
     end
-    assert_raise(TimeoutError) do
+    assert_raises(TimeoutError) do
       Net::DNS::Resolver::TcpTimeout.new(0.1).timeout { sleep 2 }
     end
   end
@@ -68,7 +68,7 @@ class TcpTimeoutTest < Test::Unit::TestCase
   end
 
   def test_timeout_should_raise_localjumperror_without_block
-    assert_raise(LocalJumpError) { Net::DNS::Resolver::TcpTimeout.new(1).timeout }
+    assert_raises(LocalJumpError) { Net::DNS::Resolver::TcpTimeout.new(1).timeout }
   end
 
 end
@@ -76,13 +76,13 @@ end
 class UdpTimeoutTest < Test::Unit::TestCase
 
   def test_initialize
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       Net::DNS::Resolver::UdpTimeout.new("a")
     end
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       Net::DNS::Resolver::UdpTimeout.new(-1)
     end
-    assert_raise(TimeoutError) do
+    assert_raises(TimeoutError) do
       Net::DNS::Resolver::UdpTimeout.new(0.1).timeout {sleep 2}
     end
   end
@@ -103,7 +103,7 @@ class UdpTimeoutTest < Test::Unit::TestCase
   end
 
   def test_timeout_should_raise_localjumperror_without_block
-    assert_raise(LocalJumpError) { Net::DNS::Resolver::UdpTimeout.new(1).timeout }
+    assert_raises(LocalJumpError) { Net::DNS::Resolver::UdpTimeout.new(1).timeout }
   end
 
 end

data/test/resolver_test.rb

@@ -9,26 +9,32 @@ end
 class ResolverTest < Test::Unit::TestCase
 
   def test_initialize
-    assert_nothing_raised { Net::DNS::Resolver.new } 
+    assert_nothing_raised { Net::DNS::Resolver.new }
   end
 
   def test_initialize_with_config
-    assert_nothing_raised { Net::DNS::Resolver.new({}) } 
+    assert_nothing_raised { Net::DNS::Resolver.new({}) }
   end
 
   def test_initialize_with_invalid_config_should_raise_argumenterror
-    assert_raise(Net::DNS::Resolver::ArgumentError) { Net::DNS::Resolver.new("") } 
-    assert_raise(Net::DNS::Resolver::ArgumentError) { Net::DNS::Resolver.new(0) } 
-    assert_raise(Net::DNS::Resolver::ArgumentError) { Net::DNS::Resolver.new(:foo) } 
+    assert_raises(ArgumentError) { Net::DNS::Resolver.new("") }
+    assert_raises(ArgumentError) { Net::DNS::Resolver.new(0) }
+    assert_raises(ArgumentError) { Net::DNS::Resolver.new(:foo) }
   end
 
+  def test_query_with_no_nameservers_should_raise_resolvererror
+    assert_raises(Net::DNS::Resolver::Error) { Net::DNS::Resolver.new(:nameservers => []).query("example.com") }
+  end
+
+  # def test_send_to_ipv6_nameserver_should_not_raise_einval
+  #   assert_nothing_raised { Net::DNS::Resolver.new(:nameservers => ['2001:4860:4860::8888', '2001:4860:4860::8844']).send('example.com')}
+  # end
 
   # I know private methods are supposed to not be tested directly
   # but since this library lacks unit tests, for now let me test them in this way.
 
   def _make_query_packet(*args)
-    # FIXME: horrible hack for horrible hack
-    Net::DNS::Resolver.new.old_send(:make_query_packet, *args)
+    Net::DNS::Resolver.new.send(:make_query_packet, *args)
   end
 
   def test_make_query_packet_from_ipaddr
@@ -76,25 +82,27 @@ class ResolverTest < Test::Unit::TestCase
     ["mswin32", true],      # ruby 1.8.6 (2008-04-22 rev 6555) [x86-jruby1.1.1]
   ]
 
+  C = Object.const_get(defined?(RbConfig) ? :RbConfig : :Config)::CONFIG
+
   def test_self_platform_windows_question
     RubyPlatforms.each do |platform, is_windows|
-      assert_equal is_windows, 
-                    override_platform(platform) { Net::DNS::Resolver.platform_windows? }, 
+      assert_equal is_windows,
+                    override_platform(platform) { Net::DNS::Resolver.platform_windows? },
                     "Expected `#{is_windows}' with platform `#{platform}'"
     end
   end
 
 
-  protected
+  private
 
-    def override_platform(new_platform, &block)
-      raise LocalJumpError, "no block given" unless block_given?
-      old_platform = Config::CONFIG["host_os"]
-      Config::CONFIG["host_os"] = new_platform
-      result = yield
-    ensure
-      Config::CONFIG["host_os"] = old_platform
-      result
-    end
+  def override_platform(new_platform, &block)
+    raise LocalJumpError, "no block given" unless block_given?
+    old_platform = C["host_os"]
+    C["host_os"] = new_platform
+    result = yield
+  ensure
+    C["host_os"] = old_platform
+    result
+  end
 
-end
+end

data/test/rr/a_test.rb

@@ -2,50 +2,56 @@ require 'test_helper'
 require 'net/dns/rr'
 
 class RRATest < Test::Unit::TestCase
-  
+
   def setup
     @rr_name    = "google.com."
     @rr_type    = "A"
     @rr_cls     = "IN"
-    @rr_ttl     = 10800
-    @rr_address = "64.233.187.99"
-    
-    @rr_output  = "google.com.             10800   IN      A       64.233.187.99"
+    @rr_ttl     = 10000
+    @rr_value   = "64.233.187.99"
+    @rr_address = IPAddr.new(@rr_value)
+
+    @rr_output  = "google.com.             10000   IN      A       64.233.187.99"
+
+    @rr         = Net::DNS::RR::A.new(:name => @rr_name, :address => @rr_address, :ttl => @rr_ttl)
   end
-  
-  
+
+
   def test_initialize_from_hash
-    @record = Net::DNS::RR::A.new(:name => @rr_name, :address => @rr_address)
-    assert_equal @rr_output,  @record.inspect
+    @record = Net::DNS::RR::A.new(:name => @rr_name, :address => @rr_value, :ttl => @rr_ttl)
+    assert_equal @rr_output,  @record.to_s
     assert_equal @rr_name,    @record.name
     assert_equal @rr_type,    @record.type
     assert_equal @rr_cls,     @record.cls
     assert_equal @rr_ttl,     @record.ttl
-    assert_equal @rr_address, @record.address.to_s
+    assert_equal @rr_address, @record.address
+    assert_equal @rr_value,   @record.value
   end
-  
+
   def test_initialize_from_string
-    @record = Net::DNS::RR::A.new("#{@rr_name} 10800 IN A #{@rr_address}")
-    assert_equal @rr_output,  @record.inspect
+    @record = Net::DNS::RR::A.new("#{@rr_name} #{@rr_ttl} #{@rr_cls} #{@rr_type} #{@rr_value}")
+    assert_equal @rr_output,  @record.to_s
     assert_equal @rr_name,    @record.name
     assert_equal @rr_type,    @record.type
     assert_equal @rr_cls,     @record.cls
     assert_equal @rr_ttl,     @record.ttl
-    assert_equal @rr_address, @record.address.to_s
+    assert_equal @rr_address, @record.address
+    assert_equal @rr_value,   @record.value
   end
-  
+
   def test_parse
-    data = "\006google\003com\000\000\001\000\001\000\000*0\000\004@\351\273c"
+    data = "\006google\003com\000\000\001\000\001\000\000'\020\000\004@\351\273c"
     @record = Net::DNS::RR.parse(data)
-    assert_equal @rr_output,  @record.inspect
+    assert_equal @rr_output,  @record.to_s
     assert_equal @rr_name,    @record.name
     assert_equal @rr_type,    @record.type
     assert_equal @rr_cls,     @record.cls
     assert_equal @rr_ttl,     @record.ttl
-    assert_equal @rr_address, @record.address.to_s
+    assert_equal @rr_address, @record.address
+    assert_equal @rr_value,   @record.value
   end
-  
-  
+
+
   InvalidArguments = [
     { :name => "google.com", :address => "255.256" },
     { :name => "google.com" },
@@ -55,12 +61,53 @@ class RRATest < Test::Unit::TestCase
     "google.com. 10800 IN B",
     "google.com. 10800 IM A",
   ]
-  
+
   InvalidArguments.each_with_index do |arguments, index|
     define_method "test_initialize_should_raise_with_invalid_arguments_#{index}" do
-      assert_raise(Net::DNS::RR::ArgumentError) { Net::DNS::RR::A.new(arguments) }
+      assert_raises(ArgumentError) { Net::DNS::RR::A.new(arguments) }
     end
   end
 
+
+  def test_address_getter
+    assert_equal  @rr_address, @rr.address
+  end
+
+  def test_address_setter
+    assert_raises(ArgumentError) { @rr.address = nil }
+
+    expected = IPAddr.new("64.233.187.99")
+    assert_equal expected, @rr.address = "64.233.187.99"
+    assert_equal expected, @rr.address
+
+    expected = IPAddr.new("64.233.187.90")
+    assert_equal expected, @rr.address = 1089059674
+    assert_equal expected, @rr.address
+
+    expected = IPAddr.new("64.233.187.80")
+    assert_equal expected, @rr.address = IPAddr.new("64.233.187.80")
+    assert_equal expected, @rr.address
+  end
+
+
+  def test_value
+    assert_equal  @rr_value, @rr.value
+  end
+
+
+  def test_inspect
+    assert_equal  "google.com.             10000   IN      A       64.233.187.99",
+                  @rr.inspect
+  end
+
+  def test_to_s
+    assert_equal  "google.com.             10000   IN      A       64.233.187.99",
+                  @rr.to_s
+  end
+
+  def test_to_a
+    assert_equal  ["google.com.", 10000, "IN", "A", "64.233.187.99"],
+                  @rr.to_a
+  end
+
 end
-