net-dns 0.6.1 → 0.7.0

data/test/rr/aaaa_test.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+require 'net/dns/rr'
+
+class RRAAAATest < Test::Unit::TestCase
+
+  def setup
+    @rr_name    = "www.nic.it."
+    @rr_type    = "AAAA"
+    @rr_cls     = "IN"
+    @rr_ttl     = 60
+    @rr_value   = "2a00:d40:1:1::239"
+    @rr_address = IPAddr.new(@rr_value)
+
+    @rr_output  = "www.nic.it.             60      IN      AAAA    2a00:d40:1:1::239"
+
+    @rr         = Net::DNS::RR::AAAA.new(:name => @rr_name, :address => @rr_address, :ttl => @rr_ttl)
+  end
+
+
+  def test_initialize_from_hash
+    @record = Net::DNS::RR::AAAA.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
+    assert_equal @rr_value,   @record.value
+  end
+
+  def test_initialize_from_string
+    @record = Net::DNS::RR::AAAA.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
+    assert_equal @rr_value,   @record.value
+  end
+
+  def test_parse
+    data = "\003www\003nic\002it\000\000\034\000\001\000\000\000<\000\020*\000\r@\000\001\000\001\000\000\000\000\000\000\0029"
+    @record = Net::DNS::RR.parse(data)
+    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
+    assert_equal @rr_value,   @record.value
+  end
+
+
+  InvalidArguments = [
+    { :name => "google.com", :address => "2a00" },
+    { :name => "google.com" },
+    Object.new,
+    Array.new(7),
+    "10800 IN AAAA",
+    # FIXME: "google.com. 10800 IN B",
+    # FIXME: "google.com. 10800 IM AAAA",
+  ]
+
+  InvalidArguments.each_with_index do |arguments, index|
+    define_method "test_initialize_should_raise_with_invalid_arguments_#{index}" do
+      assert_raises(ArgumentError) { Net::DNS::RR::AAAA.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("2a00:d40:1:1::239")
+    assert_equal expected, @rr.address = "2a00:d40:1:1::239"
+    assert_equal expected, @rr.address
+
+    expected = IPAddr.new("2a00:d40:1:1::240")
+    assert_equal expected, @rr.address = IPAddr.new("2a00:d40:1:1::240")
+    assert_equal expected, @rr.address
+  end
+
+
+  def test_value
+    assert_equal  @rr_value, @rr.value
+  end
+
+
+  def test_inspect
+    assert_equal  "www.nic.it.             60      IN      AAAA    2a00:d40:1:1::239",
+                  @rr.inspect
+  end
+
+  def test_to_s
+    assert_equal  "www.nic.it.             60      IN      AAAA    2a00:d40:1:1::239",
+                  @rr.to_s
+  end
+
+  def test_to_a
+    assert_equal  ["www.nic.it.", 60, "IN", "AAAA", "2a00:d40:1:1::239"],
+                  @rr.to_a
+  end
+
+end

data/test/rr/classes_test.rb

@@ -2,72 +2,84 @@ require 'test_helper'
 require 'net/dns/rr'
 
 class RRClassesTest < Test::Unit::TestCase
-  
+
   def setup
     @classes = {
-      'IN'        => 1,       # RFC 1035
-      'CH'        => 3,       # RFC 1035
-      'HS'        => 4,       # RFC 1035
-      'NONE'      => 254,     # RFC 2136
-      'ANY'       => 255,     # RFC 1035
     }
     @regexp_string = "ANY|CH|HS|IN|NONE"
   end
-    
-  def test_default
+
+
+  StrAndNum = [
+      ['IN'   ,   1],
+      ['CH'   ,   3],
+      ['HS'   ,   4],
+      ['NONE' , 254],
+      ['ANY'  , 255],
+  ]
+
+  StrAndNum.each do |str, num|
+    define_method "test_initialize_from_str_#{str}" do
+      instance = Net::DNS::RR::Classes.new(str)
+      assert_equal str, instance.to_s
+      assert_equal num, instance.to_i
+    end
+    define_method "test_initialize_from_num_#{num}" do
+      instance = Net::DNS::RR::Classes.new(num)
+      assert_equal str, instance.to_s
+      assert_equal num, instance.to_i
+    end
+  end
+
+  def test_initialize_should_raise_with_invalid_class
+    assert_raises(ArgumentError) { Net::DNS::RR::Classes.new(Hash.new) }
+  end
+
+
+  def test_inspect
+    assert_equal 1, Net::DNS::RR::Classes.new(1).inspect
+    assert_equal 1, Net::DNS::RR::Classes.new("IN").inspect
+  end
+
+  def test_to_s
+    assert_equal "IN", Net::DNS::RR::Classes.new(1).to_s
+    assert_equal "IN", Net::DNS::RR::Classes.new("IN").to_s
+  end
+
+  def test_to_i
+    assert_equal 1, Net::DNS::RR::Classes.new(1).to_i
+    assert_equal 1, Net::DNS::RR::Classes.new("IN").to_i
+  end
+
+
+  def test_self_default
     # Default type should be ANY => 255
     instance = Net::DNS::RR::Classes.new(nil)
-    assert_equal("1", instance.to_str)
-    assert_equal("IN", instance.to_s)
-    
+    assert_equal 1,    instance.to_i
+    assert_equal "IN", instance.to_s
+
     # Let's change default behaviour
     Net::DNS::RR::Classes.default = "CH"
     instance = Net::DNS::RR::Classes.new(nil)
-    assert_equal("3", instance.to_str)
-    assert_equal("CH", instance.to_s)
+    assert_equal 3,    instance.to_i
+    assert_equal "CH", instance.to_s
 
     Net::DNS::RR::Classes.default = "IN"
     instance = Net::DNS::RR::Classes.new(nil)
-    assert_equal("1", instance.to_str)
-    assert_equal("IN", instance.to_s)
+    assert_equal 1,    instance.to_i
+    assert_equal "IN", instance.to_s
   end
 
-  def test_classes
-    @classes.each do |key,num|
-      instance_from_string = Net::DNS::RR::Classes.new(key) 
-      instance_from_num = Net::DNS::RR::Classes.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(ClassArgumentError) do
-      Net::DNS::RR::Classes.new(Hash.new)
-    end
+  def test_self_valid?
+    assert  Net::DNS::RR::Classes.valid?("IN")
+    assert  Net::DNS::RR::Classes.valid?(1)
+    assert !Net::DNS::RR::Classes.valid?("Q")
+    assert !Net::DNS::RR::Classes.valid?(256)
+    assert_raises(ArgumentError) { Net::DNS::RR::Classes.valid?(Hash.new) }
   end
 
-  def test_regexp
-    assert_equal(@regexp_string, Net::DNS::RR::Classes.regexp)
-  end
-  
-  def test_valid
-    assert_equal(true,  Net::DNS::RR::Classes.valid?("IN"))
-    assert_equal(true,  Net::DNS::RR::Classes.valid?(1))
-    assert_equal(false, Net::DNS::RR::Classes.valid?("Q"))
-    assert_equal(false, Net::DNS::RR::Classes.valid?(256))
-    assert_raise(ClassArgumentError) do
-      Net::DNS::RR::Classes.valid? Hash.new
-    end
-  end
-
-  def test_to_str
-    assert_equal("IN", Net::DNS::RR::Classes.to_str(1))
-    assert_raise(ClassArgumentError) do
-      Net::DNS::RR::Classes.to_str(256)
-    end
-    assert_raise(ClassArgumentError) do
-      Net::DNS::RR::Classes.to_str("string")
-    end
+  def test_self_regexp
+    assert_equal @regexp_string, Net::DNS::RR::Classes.regexp
   end
 
 end

data/test/rr/cname_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+require 'net/dns/rr'
+
+class RRCNAMETest < Test::Unit::TestCase
+
+  def setup
+    @rr_name    = "www.google.com."
+    @rr_type    = "CNAME"
+    @rr_cls     = "IN"
+    @rr_ttl     = 550317
+    @rr_value   = "www.l.google.com."
+    @rr_cname   = @rr_value
+
+    @rr_output  = "www.google.com.         550317  IN      CNAME   www.l.google.com."
+
+    @rr         = Net::DNS::RR::CNAME.new(:name => @rr_name, :cname => @rr_cname, :ttl => @rr_ttl)
+  end
+
+
+  def test_initialize_from_hash
+    @record = Net::DNS::RR::CNAME.new(:name => @rr_name, :cname => @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_cname,   @record.cname
+    assert_equal @rr_value,   @record.value
+  end
+
+  def test_initialize_from_string
+    @record = Net::DNS::RR::CNAME.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_cname,   @record.cname
+    assert_equal @rr_value,   @record.value
+  end
+
+  def test_parse
+    data = "\003www\006google\003com\000\000\005\000\001\000\be\255\000\022\003www\001l\006google\003com\000"
+    @record = Net::DNS::RR.parse(data)
+    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_cname,   @record.cname
+    assert_equal @rr_value,   @record.value
+  end
+
+
+  InvalidArguments = [
+    # FIXME: { :name => "google.com", :cname => "foo___bar" },
+    # FIXME: { :name => "google.com", :cname => "foo$bar" },
+    { :name => "google.com" },
+    Object.new,
+    Array.new(7),
+    "10800 IN CNAME",
+    "google.com. 10800 IN CNAME",
+  ]
+
+  InvalidArguments.each_with_index do |arguments, index|
+    define_method "test_initialize_should_raise_with_invalid_arguments_#{index}" do
+      assert_raises(ArgumentError) { p Net::DNS::RR::CNAME.new(arguments) }
+    end
+  end
+
+
+  def test_cname_getter
+    assert_equal  @rr_cname, @rr.cname
+  end
+
+
+  def test_value
+    assert_equal  @rr_value, @rr.value
+  end
+
+
+  def test_inspect
+    assert_equal  "www.google.com.         550317  IN      CNAME   www.l.google.com.",
+                  @rr.inspect
+  end
+
+  def test_to_s
+    assert_equal  "www.google.com.         550317  IN      CNAME   www.l.google.com.",
+                  @rr.to_s
+  end
+
+  def test_to_a
+    assert_equal  ["www.google.com.", 550317, "IN", "CNAME", "www.l.google.com."],
+                  @rr.to_a
+  end
+
+end

data/test/rr/hinfo_test.rb

@@ -0,0 +1,117 @@
+require 'test_helper'
+require 'net/dns/rr'
+require 'net/dns/rr/hinfo'
+
+class RRHINFOTest < Test::Unit::TestCase
+
+  def setup
+    @rr_name    = ""
+    @rr_type    = "HINFO"
+    @rr_cls     = "IN"
+    @rr_ttl     = nil
+    @rr_value   = %Q{"PC-Intel-700mhz" "Redhat Linux 7.1"}
+    @rr_output  = %Q{                                IN      HINFO   "PC-Intel-700mhz" "Redhat Linux 7.1"}
+
+    @rr_cpu     = "PC-Intel-700mhz"
+    @rr_os      = "Redhat Linux 7.1"
+
+    @rr         = Net::DNS::RR::HINFO.new(:name => @rr_name, :cpu => @rr_cpu, :os => @rr_os)
+  end
+
+
+  def test_initialize_from_hash
+    @record = Net::DNS::RR::HINFO.new(:name => @rr_name, :cpu => @rr_cpu, :os => @rr_os)
+    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 10800,       @record.ttl
+    assert_equal @rr_value,   @record.value
+
+    assert_equal @rr_cpu,     @record.cpu
+    assert_equal @rr_os,      @record.os
+  end
+
+  def test_initialize_from_string
+    @record = Net::DNS::RR::HINFO.new(%Q{#{@rr_name} #{@rr_ttl} #{@rr_cls} #{@rr_type} PC-Intel-700mhz "Redhat Linux 7.1"})
+    assert_equal @rr_output,  @record.to_s
+    assert_equal @rr_value,   @record.value
+
+    assert_equal @rr_cpu,     @record.cpu
+    assert_equal @rr_os,      @record.os
+  end
+
+  def test_initialize_from_string_without_quotes
+    @record = Net::DNS::RR::HINFO.new("#{@rr_name} #{@rr_ttl} #{@rr_cls} #{@rr_type} #{@rr_value}")
+    assert_equal @rr_output,  @record.to_s
+    # FIXME: assert_equal @rr_name,    @record.name
+    assert_equal @rr_type,    @record.type
+    assert_equal @rr_cls,     @record.cls
+    assert_equal 10800,       @record.ttl
+    assert_equal @rr_value,   @record.value
+
+    assert_equal @rr_cpu,     @record.cpu
+    assert_equal @rr_os,      @record.os
+  end
+
+  # FIXME: Can't get valid data
+  # def test_parse
+  #   data = "\002in\000\000\r\000\001\000\000*0\000!\017PC-Intel-700mhz\020Redhat Linux 7.1"
+  #   @record = Net::DNS::RR.parse(data)
+  #   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_value,   @record.value
+  #
+  #   assert_equal @rr_cpu,     @record.cpu
+  #   assert_equal @rr_os,      @record.os
+  # end
+
+
+  InvalidArguments = [
+    { :name => "google.com" },
+    Object.new,
+    Array.new(7),
+    "10800 IN HINFO",
+    "IN HINFO",
+  ]
+
+  InvalidArguments.each_with_index do |arguments, index|
+    define_method "test_initialize_should_raise_with_invalid_arguments_#{index}" do
+      assert_raises(ArgumentError) { p Net::DNS::RR::HINFO.new(arguments) }
+    end
+  end
+
+
+  def test_cpu
+    assert_equal  @rr_cpu, @rr.cpu
+  end
+
+  def test_os
+    assert_equal  @rr_os, @rr.os
+  end
+
+
+  def test_value
+    assert_equal  %Q{"PC-Intel-700mhz" "Redhat Linux 7.1"}, @rr.value
+  end
+
+
+  def test_inspect
+    assert_equal  %Q{                                IN      HINFO   "PC-Intel-700mhz" "Redhat Linux 7.1"},
+                  @rr.inspect
+  end
+
+  def test_to_s
+    assert_equal  %Q{                                IN      HINFO   "PC-Intel-700mhz" "Redhat Linux 7.1"},
+                  @rr.to_s
+  end
+
+  def test_to_a
+    assert_equal  [nil, nil, "IN", "HINFO", %Q{"PC-Intel-700mhz" "Redhat Linux 7.1"}],
+                  @rr.to_a
+  end
+
+end