net-dns 0.5.3 → 0.6.0

data/test/{net/dns/test_packet.rb → packet_test.rb}

@@ -1,7 +1,7 @@
-require 'test/unit'
+require 'test_helper'
 require 'net/dns/packet'
 
-class Test_Packet < Test::Unit::TestCase
+class PacketTest < Test::Unit::TestCase
   include Net::DNS
 
   def setup

data/test/question_test.rb

@@ -0,0 +1,84 @@
+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)
+  end
+  
+  def test_simple
+    assert_equal(@default.qName, @domain)
+    assert_equal(@default.qType.to_s, "A")
+    assert_equal(@default.qClass.to_s, "IN")
+
+    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{")
+    end
+    assert_raise(Net::DNS::Question::ArgumentError) do
+      Question.parse(Array.new)
+    end
+    assert_raise(Net::DNS::Question::ArgumentError) do
+      Question.parse("test")
+    end
+  end
+  
+  def test_inspect
+    assert_equal  "google.com.                  IN      A       ",
+                  Net::DNS::Question.new("google.com.").inspect
+    assert_equal  "google.com.                  IN      A       ",
+                  Net::DNS::Question.new("google.com.", Net::DNS::A).inspect
+    assert_equal  "google.com.                  IN      NS      ",
+                  Net::DNS::Question.new("google.com.", Net::DNS::NS).inspect
+    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
+    assert_equal  "google.com.                  IN      A       ",
+                  Net::DNS::Question.new("google.com.", Net::DNS::A).to_s
+    assert_equal  "google.com.                  IN      NS      ",
+                  Net::DNS::Question.new("google.com.", Net::DNS::NS).to_s
+    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    

data/test/resolver/timeouts_test.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+require 'net/dns/resolver/timeouts'
+
+class DnsTimeoutTest < Test::Unit::TestCase
+
+  def setup
+    @klass = Net::DNS::Resolver::DnsTimeout
+  end
+
+  def test_initialize
+    timeout = @klass.new(0)
+    assert_instance_of @klass, timeout
+  end
+
+  def test_initialize_should_set_timeout
+    assert_equal 0, @klass.new(0).seconds
+    assert_equal 10, @klass.new(10).seconds
+  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) }
+  end
+
+
+  def test_to_s
+    assert_equal "", @klass.new(0).to_s
+    assert_equal "1", @klass.new(1).to_s
+    assert_equal "10", @klass.new(10).to_s
+  end
+
+
+  def test_timeout_should_raise_localjumperror_without_block
+    assert_raise(LocalJumpError) { @klass.new(1).timeout }
+  end
+
+end
+
+class TcpTimeoutTest < Test::Unit::TestCase
+
+  def test_initialize
+    assert_raise(ArgumentError) do
+      Net::DNS::Resolver::TcpTimeout.new("a")
+    end
+    assert_raise(ArgumentError) do
+      Net::DNS::Resolver::TcpTimeout.new(-1)
+    end
+    assert_raise(TimeoutError) do
+      Net::DNS::Resolver::TcpTimeout.new(0.1).timeout { sleep 2 }
+    end
+  end
+
+  def test_to_s
+    assert_equal "infinite", Net::DNS::Resolver::TcpTimeout.new(0).to_s
+    assert_equal "30", Net::DNS::Resolver::TcpTimeout.new(30).to_s
+  end
+
+  def test_pretty_to_s
+    assert_equal "30 seconds", Net::DNS::Resolver::TcpTimeout.new(30).pretty_to_s
+    assert_equal "1 minutes and 30 seconds", Net::DNS::Resolver::TcpTimeout.new(90).pretty_to_s
+    assert_equal "1 hours, 1 minutes and 30 seconds", Net::DNS::Resolver::TcpTimeout.new(3690).pretty_to_s
+  end
+
+  def test_timeout
+    assert_equal 2, Net::DNS::Resolver::TcpTimeout.new(1).timeout { 1 + 1 }
+  end
+
+  def test_timeout_should_raise_localjumperror_without_block
+    assert_raise(LocalJumpError) { Net::DNS::Resolver::TcpTimeout.new(1).timeout }
+  end
+
+end
+
+class UdpTimeoutTest < Test::Unit::TestCase
+
+  def test_initialize
+    assert_raise(ArgumentError) do
+      Net::DNS::Resolver::UdpTimeout.new("a")
+    end
+    assert_raise(ArgumentError) do
+      Net::DNS::Resolver::UdpTimeout.new(-1)
+    end
+    assert_raise(TimeoutError) do
+      Net::DNS::Resolver::UdpTimeout.new(0.1).timeout {sleep 2}
+    end
+  end
+
+  def test_to_s
+    assert_equal "not defined", Net::DNS::Resolver::UdpTimeout.new(0).to_s
+    assert_equal "30", Net::DNS::Resolver::UdpTimeout.new(30).to_s
+  end
+
+  def test_pretty_to_s
+    assert_equal "30 seconds", Net::DNS::Resolver::UdpTimeout.new(30).pretty_to_s
+    assert_equal "1 minutes and 30 seconds", Net::DNS::Resolver::UdpTimeout.new(90).pretty_to_s
+    assert_equal "1 hours, 1 minutes and 30 seconds", Net::DNS::Resolver::UdpTimeout.new(3690).pretty_to_s
+  end
+
+  def test_timeout
+    assert_equal 2, Net::DNS::Resolver::UdpTimeout.new(1).timeout { 1 + 1 }
+  end
+
+  def test_timeout_should_raise_localjumperror_without_block
+    assert_raise(LocalJumpError) { Net::DNS::Resolver::UdpTimeout.new(1).timeout }
+  end
+
+end

data/test/{net/dns/test_resolver.rb → resolver_test.rb}

@@ -1,4 +1,4 @@
-require 'test/unit'
+require 'test_helper'
 require 'net/dns/resolver'
 
 class Net::DNS::Resolver
@@ -6,7 +6,7 @@ class Net::DNS::Resolver
 end
 
 
-class TestResolver < Test::Unit::TestCase
+class ResolverTest < Test::Unit::TestCase
   
   def test_initialize
     assert_nothing_raised { Net::DNS::Resolver.new } 
@@ -16,10 +16,10 @@ class TestResolver < Test::Unit::TestCase
     assert_nothing_raised { Net::DNS::Resolver.new({}) } 
   end
   
-  def test_initialize_with_invalid_config_should_raise_error
-    assert_raise(ResolverArgumentError) { Net::DNS::Resolver.new("") } 
-    assert_raise(ResolverArgumentError) { Net::DNS::Resolver.new(0) } 
-    assert_raise(ResolverArgumentError) { Net::DNS::Resolver.new(:foo) } 
+  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) } 
   end
   
   

data/test/rr/a_test.rb

@@ -0,0 +1,66 @@
+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"
+  end
+  
+  
+  def test_initialize_from_hash
+    @record = Net::DNS::RR::A.new(:name => @rr_name, :address => @rr_address)
+    assert_equal @rr_output,  @record.inspect
+    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
+  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
+    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
+  end
+  
+  def test_parse
+    data = "\006google\003com\000\000\001\000\001\000\000*0\000\004@\351\273c"
+    @record = Net::DNS::RR.parse(data)
+    assert_equal @rr_output,  @record.inspect
+    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
+  end
+  
+  
+  InvalidArguments = [
+    { :name => "google.com", :address => "255.256" },
+    { :name => "google.com" },
+    Object.new,
+    Array.new(7),
+    "10800 IN A",
+    "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) }
+    end
+  end
+
+end
+    

data/test/{net/dns/rr/test_classes.rb → rr/classes_test.rb}

@@ -1,7 +1,8 @@
-require 'test/unit'
-require 'net/dns/rr/classes'
+require 'test_helper'
+require 'net/dns/rr'
 
-class Test_Classes < Test::Unit::TestCase
+class RRClassesTest < Test::Unit::TestCase
+  
   def setup
     @classes = {
       'IN'        => 1,       # RFC 1035
@@ -10,7 +11,7 @@ class Test_Classes < Test::Unit::TestCase
       'NONE'      => 254,     # RFC 2136
       'ANY'       => 255,     # RFC 1035
     }
-    @regexp_string = "HS|ANY|NONE|CH|IN"
+    @regexp_string = "ANY|CH|HS|IN|NONE"
   end
     
   def test_default
@@ -29,7 +30,6 @@ class Test_Classes < Test::Unit::TestCase
     instance = Net::DNS::RR::Classes.new(nil)
     assert_equal("1", instance.to_str)
     assert_equal("IN", instance.to_s)
-    
   end
 
   def test_classes

data/test/rr/ns_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+require 'net/dns/rr'
+
+class RRNSTest < Test::Unit::TestCase
+  
+  def setup
+    @rr_name    = "google.com."
+    @rr_type    = "NS"
+    @rr_cls     = "IN"
+    @rr_ttl     = 10800
+    @rr_nsdname = "ns1.google.com."
+    
+    @rr_output  = "google.com.             10800   IN      NS      ns1.google.com."
+  end
+  
+  
+  def test_initialize_from_hash
+    @record = Net::DNS::RR::NS.new(:name => @rr_name, :nsdname => @rr_nsdname)
+    assert_equal @rr_output,  @record.inspect
+    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_nsdname, @record.nsdname
+  end
+  
+  def test_initialize_from_string
+    @record = Net::DNS::RR::NS.new("#{@rr_name} 10800 IN NS #{@rr_nsdname}")
+    assert_equal @rr_output,  @record.inspect
+    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_nsdname, @record.nsdname
+  end
+  
+  def test_parse
+    data = "\006google\003com\000\000\002\000\001\000\000*0\000\020\003ns1\006google\003com\000"
+    @record = Net::DNS::RR.parse(data)
+    assert_equal @rr_output,  @record.inspect
+    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_nsdname, @record.nsdname
+  end
+  
+  
+  InvalidArguments = [
+    { :name => "google.com", :address => "255.256" },
+    { :name => "google.com" },
+    Object.new,
+    Array.new(7),
+    "10800 IN 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) }
+    end
+  end
+
+end
+    

data/test/rr/types_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+require 'net/dns/rr'
+
+class RRTypesTest < Test::Unit::TestCase
+
+  def setup
+  end
+    
+  def test_default
+    # Default type should be ANY => 255
+    instance = Net::DNS::RR::Types.new(nil)
+    assert_equal("1", instance.to_str)
+    assert_equal("A", instance.to_s)
+    
+    # Let's change default behaviour
+    Net::DNS::RR::Types.default = "A"
+    instance = Net::DNS::RR::Types.new(nil)
+    assert_equal("1", instance.to_str)
+    assert_equal("A", instance.to_s)
+
+    Net::DNS::RR::Types.default = "ANY"
+    instance = Net::DNS::RR::Types.new(nil)
+    assert_equal("255", instance.to_str)
+    assert_equal("ANY", instance.to_s)
+  end
+
+  def test_types
+    Net::DNS::RR::Types::TYPES.each do |key, num|
+      instance_from_string = Net::DNS::RR::Types.new(key)
+      instance_from_num = Net::DNS::RR::Types.new(num)
+      assert_equal(key, instance_from_string.to_s)
+      assert_equal(num.to_s, instance_from_string.to_str)
+      assert_equal(key, instance_from_num.to_s)
+      assert_equal(num.to_s, instance_from_num.to_str)
+    end
+    assert_raise(Net::DNS::RR::ArgumentError) do
+      Net::DNS::RR::Types.new(Hash.new)
+    end
+  end
+
+  def test_regexp
+    pattern = Net::DNS::RR::Types.regexp
+    assert_instance_of String, pattern
+    Net::DNS::RR::Types::TYPES.each do |key, num|
+      assert_match /\|?#{key}\|?/, pattern
+    end
+  end
+  
+  def test_valid?
+    assert_equal(true,  Net::DNS::RR::Types.valid?("A"))
+    assert_equal(true,  Net::DNS::RR::Types.valid?(1))
+    assert_equal(false, Net::DNS::RR::Types.valid?("Q"))
+    assert_equal(false, Net::DNS::RR::Types.valid?(256))
+    assert_raise(Net::DNS::RR::ArgumentError) do
+      Net::DNS::RR::Types.valid? Hash.new
+    end
+  end
+
+  def test_to_str
+    assert_equal("A", Net::DNS::RR::Types.to_str(1))
+    assert_raise(Net::DNS::RR::ArgumentError) do
+      Net::DNS::RR::Types.to_str(256)
+    end
+    assert_raise(Net::DNS::RR::ArgumentError) do
+      Net::DNS::RR::Types.to_str("string")
+    end
+  end
+
+end