whois 1.2.2 → 1.3.0

data/test/whois/answer/parser/whois.za.net_test.rb

@@ -1,62 +0,0 @@
-require 'test_helper'
-require 'whois/answer/parser/whois.za.net'
-
-class AnswerParserWhoisZaNetTest < Whois::Answer::Parser::TestCase
-
-  def setup
-    @klass  = Whois::Answer::Parser::WhoisZaNet
-    @host   = "whois.za.net"
-  end
-
-
-  def test_status
-    assert_equal  :registered,
-                  @klass.new(load_part('/registered.txt')).status
-    assert_equal  :available,
-                  @klass.new(load_part('/available.txt')).status
-  end
-
-  def test_available?
-    assert !@klass.new(load_part('/registered.txt')).available?
-    assert  @klass.new(load_part('/available.txt')).available?
-  end
-
-  def test_registered?
-    assert  @klass.new(load_part('/registered.txt')).registered?
-    assert !@klass.new(load_part('/available.txt')).registered?
-  end
-
-
-  def test_created_on
-    assert_equal  Time.parse("2002-03-29 22:03:53 GMT"),
-                  @klass.new(load_part('/registered.txt')).created_on
-    assert_equal  nil,
-                  @klass.new(load_part('/available.txt')).created_on
-  end
-
-  def test_updated_on
-    assert_equal  Time.parse("2002-03-29 22:03:53 GMT"),
-                  @klass.new(load_part('/registered.txt')).updated_on
-    assert_equal  nil,
-                  @klass.new(load_part('/available.txt')).updated_on
-  end
-
-  def test_expires_on
-    assert_raise(Whois::PropertyNotSupported) { @klass.new(load_part('/registered.txt')).expires_on }
-    assert_raise(Whois::PropertyNotSupported) { @klass.new(load_part('/available.txt')).expires_on }
-  end
-
-
-  def test_nameservers
-    parser    = @klass.new(load_part('/registered.txt'))
-    expected  = %w( ns3.zoneedit.com ns5.zoneedit.com )
-    assert_equal  expected, parser.nameservers
-    assert_equal  expected, parser.instance_eval { @nameservers }
-
-    parser    = @klass.new(load_part('/available.txt'))
-    expected  = %w()
-    assert_equal  expected, parser.nameservers
-    assert_equal  expected, parser.instance_eval { @nameservers }
-  end
-
-end

data/test/whois/answer/parser/whois.za.org_test.rb

@@ -1,62 +0,0 @@
-require 'test_helper'
-require 'whois/answer/parser/whois.za.org'
-
-class AnswerParserWhoisZaOrgTest < Whois::Answer::Parser::TestCase
-
-  def setup
-    @klass  = Whois::Answer::Parser::WhoisZaOrg
-    @host   = "whois.za.org"
-  end
-
-
-  def test_status
-    assert_equal  :registered,
-                  @klass.new(load_part('/registered.txt')).status
-    assert_equal  :available,
-                  @klass.new(load_part('/available.txt')).status
-  end
-
-  def test_available?
-    assert !@klass.new(load_part('/registered.txt')).available?
-    assert  @klass.new(load_part('/available.txt')).available?
-  end
-
-  def test_registered?
-    assert  @klass.new(load_part('/registered.txt')).registered?
-    assert !@klass.new(load_part('/available.txt')).registered?
-  end
-
-
-  def test_created_on
-    assert_equal  Time.parse("2000-11-05 14:03:48 GMT"),
-                  @klass.new(load_part('/registered.txt')).created_on
-    assert_equal  nil,
-                  @klass.new(load_part('/available.txt')).created_on
-  end
-
-  def test_updated_on
-    assert_equal  Time.parse("2005-08-15 12:15:10 BST"),
-                  @klass.new(load_part('/registered.txt')).updated_on
-    assert_equal  nil,
-                  @klass.new(load_part('/available.txt')).updated_on
-  end
-
-  def test_expires_on
-    assert_raise(Whois::PropertyNotSupported) { @klass.new(load_part('/registered.txt')).expires_on }
-    assert_raise(Whois::PropertyNotSupported) { @klass.new(load_part('/available.txt')).expires_on }
-  end
-
-
-  def test_nameservers
-    parser    = @klass.new(load_part('/registered.txt'))
-    expected  = %w( blade.wcic.co.za sabertooth.wcic.co.za ns2.iafrica.com )
-    assert_equal  expected, parser.nameservers
-    assert_equal  expected, parser.instance_eval { @nameservers }
-
-    parser    = @klass.new(load_part('/available.txt'))
-    expected  = %w()
-    assert_equal  expected, parser.nameservers
-    assert_equal  expected, parser.instance_eval { @nameservers }
-  end
-
-end

data/test/whois/answer/parser_test.rb

@@ -1,219 +0,0 @@
-require 'test_helper'
-
-class AnswerParserTest < Test::Unit::TestCase
-
-  class Whois::Answer::Parser::WhoisAnswerParser1Fake < Whois::Answer::Parser::Base
-  end
-
-  class Whois::Answer::Parser::WhoisAnswerParser2Fake < Whois::Answer::Parser::Base
-    property_supported(:technical_contact)   { "p2-t1" }
-    property_supported(:admin_contact)       { "p2-a1" }
-    property_supported(:registrant_contact)  { nil }
-  end
-
-  class Whois::Answer::Parser::WhoisAnswerParser3Fake < Whois::Answer::Parser::Base
-    property_supported(:technical_contact)   { "p3-t1" }
-  end
-
-
-  def setup
-    @klass  = Whois::Answer::Parser
-    @answer = Whois::Answer.new(nil, [])
-    @parser = @klass.new(@answer)
-  end
-
-
-  def test_initialize
-    parser = @klass.new(@answer)
-    assert_instance_of @klass, parser
-    assert_equal @answer, parser.answer
-  end
-
-  def test_initialize_should_require_answer
-    assert_raise(ArgumentError) { @klass.new }
-  end
-
-
-  def test_parsers_with_zero_parts
-    answer = Whois::Answer.new(nil, [])
-    parser = @klass.new(answer)
-    assert_equal 0, parser.parsers.length
-    assert_equal [], parser.parsers
-  end
-
-  def test_parsers_with_one_part_supported
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "whois.nic.it")])
-    parser = @klass.new(answer)
-    assert_equal 1, parser.parsers.length
-    assert_instance_of Whois::Answer::Parser::WhoisNicIt, parser.parsers.first
-  end
-
-  def test_parsers_with_one_part_unsupported
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "invalid.nic.it")])
-    parser = @klass.new(answer)
-    assert_equal 1, parser.parsers.length
-    assert_instance_of Whois::Answer::Parser::Blank, parser.parsers.first
-  end
-
-  def test_parsers_with_two_parts
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "whois.crsnic.net"), Whois::Answer::Part.new(nil, "whois.nic.it")])
-    parser = @klass.new(answer)
-    assert_equal 2, parser.parsers.length
-    assert_instance_of Whois::Answer::Parser::WhoisNicIt, parser.parsers.first
-    assert_instance_of Whois::Answer::Parser::WhoisCrsnicNet, parser.parsers.last
-  end
-
-
-  def test_property_supported_with_zero_parts
-    answer = Whois::Answer.new(nil, [])
-    parser = @klass.new(answer)
-    assert !parser.property_supported?(:disclaimer)
-  end
-
-  def test_property_supported_with_one_part_supported
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "whois.nic.it")])
-    parser = @klass.new(answer)
-    assert  parser.property_supported?(:disclaimer)
-  end
-
-  def test_property_supported_with_one_part_unsupported
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "invalid.nic.it")])
-    parser = @klass.new(answer)
-    assert !parser.property_supported?(:disclaimer)
-  end
-
-  def test_property_supported_with_two_parts
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "whois.crsnic.net"), Whois::Answer::Part.new(nil, "whois.nic.it")])
-    parser = @klass.new(answer)
-    assert  parser.property_supported?(:disclaimer)
-  end
-
-
-  def test_contacts_with_zero_parts
-    answer = Whois::Answer.new(nil, [])
-    parser = @klass.new(answer)
-    assert_equal 0, parser.contacts.length
-    assert_equal [], parser.contacts
-  end
-
-  def test_contacts_with_one_part
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "whois.answer-parser2.fake")])
-    parser = @klass.new(answer)
-    assert_equal 2, parser.contacts.length
-    assert_equal ["p2-a1", "p2-t1"], parser.contacts
-  end
-
-  def test_contacts_with_one_part_unsupported
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "whois.answer-parser1.fake")])
-    parser = @klass.new(answer)
-    assert_equal 0, parser.contacts.length
-    assert_equal [], parser.contacts
-  end
-
-  def test_contacts_with_two_parts
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new(nil, "whois.answer-parser2.fake"), Whois::Answer::Part.new(nil, "whois.answer-parser3.fake")])
-    parser = @klass.new(answer)
-    assert_equal 3, parser.contacts.length
-    assert_equal ["p3-t1", "p2-a1", "p2-t1"], parser.contacts
-  end
-
-
-  class Whois::Answer::Parser::TestParserSupported < Whois::Answer::Parser::Base
-    property_supported :status do
-      :status_supported
-    end
-    property_supported :created_on do
-      :created_on_supported
-    end
-    property_supported :updated_on do
-      :updated_on_supported
-    end
-    property_supported :expires_on do
-      :expires_on_supported
-    end
-  end
-
-  class Whois::Answer::Parser::TestParserUndefined < Whois::Answer::Parser::Base
-    property_supported :status do
-      :status_undefined
-    end
-    # not defined          :created_on
-    # not defined          :updated_on
-    # not defined          :expires_on
-  end
-
-  class Whois::Answer::Parser::TestParserUnsupported < Whois::Answer::Parser::Base
-    property_not_supported :status
-    property_not_supported :created_on
-    property_not_supported :updated_on
-    property_not_supported :expires_on
-  end
-
-  def test_delegate_property_to_parsers_should_delegate_to_first_with_all_supported
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "test.parser.supported"), Whois::Answer::Part.new("", "test.parser.undefined")])
-    parser = @klass.new(answer)
-    assert_equal :status_undefined, parser.status
-
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "test.parser.undefined"), Whois::Answer::Part.new("", "test.parser.supported")])
-    parser = @klass.new(answer)
-    assert_equal :status_supported, parser.status
-  end
-
-  def test_delegate_property_to_parsers_should_delegate_to_first_with_one_supported
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "test.parser.supported"), Whois::Answer::Part.new("", "test.parser.undefined")])
-    parser = @klass.new(answer)
-    assert_equal :created_on_supported, parser.created_on
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "test.parser.supported"), Whois::Answer::Part.new("", "test.parser.unsupported")])
-    parser = @klass.new(answer)
-    assert_equal :created_on_supported, parser.created_on
-  end
-
-  def test_delegate_property_to_parsers_should_raise_unless_supported
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "test.parser.unsupported"), Whois::Answer::Part.new("", "test.parser.unsupported")])
-    parser = @klass.new(answer)
-    assert_raise(Whois::PropertyNotSupported) { parser.created_on }
-  end
-
-  def test_delegate_property_to_parsers_should_raise_unless_available
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "test.parser.undefined"), Whois::Answer::Part.new("", "test.parser.undefined")])
-    parser = @klass.new(answer)
-    assert_raise(Whois::PropertyNotAvailable) { parser.created_on }
-  end
-
-  def test_delegate_property_to_parsers_should_raise_with_zero_parts
-    answer = Whois::Answer.new(nil, [])
-    parser = @klass.new(answer)
-    assert_raise(Whois::ParserError) { parser.created_on }
-  end
-
-  def test_delegate_property_to_parser_should_not_delegate_unallowed_methods
-    answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "whois.nic.it")])
-    parser = @klass.new(answer)
-    parser.parsers.expects("unallowed_method").never
-    assert_raise(NoMethodError) { parser.send("unallowed_method") }
-  end
-
-
-  def test_self_parser_klass
-    assert_equal "Whois::Answer::Parser::WhoisNicIt", @klass.parser_klass("whois.nic.it").name
-  end
-
-  def test_self_parser_klass_with_preloaded_class
-    @klass.class_eval <<-RUBY
-      class WhoisFooBar
-      end
-    RUBY
-    assert_equal "Whois::Answer::Parser::WhoisFooBar", @klass.parser_klass("whois.foo.bar").name
-  end
-
-  def test_self_parser_klass_should_return_blank_class_if_parser_doesnt_exist
-    assert_equal "Whois::Answer::Parser::Blank", @klass.parser_klass("whois.missing").name
-  end
-
-  def test_self_host_to_parser
-    assert_equal "WhoisIt", @klass.host_to_parser("whois.it")
-    assert_equal "WhoisNicIt", @klass.host_to_parser("whois.nic.it")
-    assert_equal "WhoisDomainRegistryNl", @klass.host_to_parser("whois.domain-registry.nl")
-  end
-
-end

data/test/whois/answer/super_struct_test.rb

@@ -1,24 +0,0 @@
-require 'test_helper'
-
-class SuperStructTest < Test::Unit::TestCase
-
-  SuperEroe = Class.new(SuperStruct.new(:name, :supername))
-
-  def setup
-    @klass = SuperEroe
-  end
-
-  def test_initialize_with_block
-    @klass.new do |instance|
-      assert_instance_of  SuperEroe, instance
-      assert_kind_of      SuperStruct, instance
-    end
-  end
-
-  def test_initialize_with_hash
-    instance = @klass.new(:name => "Pippo", :supername => "SuperPippo")
-    assert_equal "Pippo", instance.name
-    assert_equal "SuperPippo", instance.supername
-  end
-
-end

data/test/whois/answer_test.rb

@@ -1,180 +0,0 @@
-require 'test_helper'
-
-class AnswerTest < Test::Unit::TestCase
-
-  def setup
-    @klass    = Whois::Answer
-    @server   = Whois::Server.factory(:tld, ".foo", "whois.foo")
-    @parts    = [
-        Whois::Answer::Part.new("This is a answer for domain.foo.", "foo.whois.com"),
-        Whois::Answer::Part.new("This is a answer for domain.bar.", "bar.whois.com")
-    ]
-    @content  = "This is a answer for domain.foo.\nThis is a answer for domain.bar."
-    @answer   = @klass.new(@server, @parts)
-  end
-
-
-  def test_initialize
-    answer = @klass.new(@server, @parts)
-    assert_instance_of @klass, answer
-    assert_equal @server, answer.server
-    assert_equal @parts, answer.parts
-  end
-
-  def test_initialize_should_require_server
-    assert_raise(ArgumentError) { @klass.new }
-  end
-
-  def test_initialize_should_require_parts
-    assert_raise(ArgumentError) { @klass.new(@server) }
-  end
-
-
-  def test_to_s
-    assert_equal @content, @answer.to_s
-  end
-
-  def test_inspect
-    assert_equal @content.inspect, @answer.inspect
-  end
-
-  def test_match
-    # Force .to_a otherwise Match will be compared as Object instance
-    # and the test will fail because they actually are different instances.
-    assert_equal @content.match(/domain\.foo/).to_a, @answer.match(/domain\.foo/).to_a
-    assert_equal @content.match(/google/), @answer.match(/google/)
-  end
-
-  def test_match?
-    assert  @answer.match?(/domain\.foo/)
-    assert !@answer.match?(/google/)
-  end
-
-  def test_equality_with_check_self
-    assert_equal @answer, @answer
-    assert  @answer.eql?(@answer)
-  end
-
-  def test_equality_with_check_self_class
-    assert_equal @answer, @answer.dup
-    assert  @answer.eql?(@answer.dup)
-  end
-
-  def test_equality_with_check_self_subclass
-    child = Class.new(@klass)
-    
-    assert_equal @answer, child.new(@answer.server, @answer.parts)
-    assert  @answer.eql?(child.new(@answer.server, @answer.parts))
-  end
-
-  def test_equality_with_check_string
-    assert_equal      @answer, @content
-    assert_not_equal  @content, @answer
-    assert  @answer.eql?(@content)
-    assert !@content.eql?(@answer)
-  end
-
-  def test_equality_check_content
-    other = @klass.new(@server, @parts)
-    assert_equal @answer, other
-    assert_equal other, @answer
-    assert @answer.eql?(other)
-    assert other.eql?(@answer)
-  end
-
-
-  def test_content
-    answer = @klass.new(@server, @parts)
-    assert_equal @content, answer.content
-  end
-
-
-  def test_contacts
-    answer = @klass.new(@server, @parts)
-    answer.parser.expects(:contacts).returns([])
-    assert_equal [], answer.contacts
-  end
-
-  def test_throttle_question
-    answer = @klass.new(@server, @parts)
-    answer.parser.expects(:throttle?).returns(true)
-    assert_equal true, answer.throttle?
-  end
-
-
-  def test_parser
-    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.nic.it")])
-    assert_instance_of Whois::Answer::Parser, answer.parser
-
-    answer = @klass.new(nil, [])
-    assert_instance_of Whois::Answer::Parser, answer.parser
-  end
-
-
-  class Whois::Answer::Parser::WhoisParserFake < Whois::Answer::Parser::Base
-    property_supported :status do
-      nil
-    end
-    property_supported :created_on do
-      Date.parse("2010-10-20")
-    end
-    property_not_supported :updated_on
-    # property_not_defined :expires_on
-  end
-
-  def test_property_supported?
-    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
-    assert  answer.property_supported?(:status)
-    assert  answer.property_supported?(:created_on)
-    assert !answer.property_supported?(:updated_on)
-    assert !answer.property_supported?(:expires_on)
-  end
-
-  # DEPRECATED
-  def test_properties
-    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
-    properties = answer.properties
-
-    assert_equal Whois::Answer::Parser.properties.size, properties.keys.size
-    assert_equal nil,                       properties[:status]
-    assert_equal Date.parse("2010-10-20"),  properties[:created_on]
-    assert_equal nil,                       properties[:updated_on]
-    assert_equal nil,                       properties[:expires_on]
-  end
-
-  def test_should_return_value_with_supported_property_getter
-    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
-    assert_equal Date.parse("2010-10-20"), answer.created_on
-  end
-
-  def test_should_return_nil_with_not_supported_property_getter
-    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
-    assert_equal nil, answer.updated_on
-  end
-
-  def test_should_return_nil_with_not_implemented_property
-    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
-    assert_equal nil, answer.expires_on
-  end
-
-  def test_should_return_false_with_supported_property_getter_and_not_value
-    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
-    assert !answer.status?
-  end
-
-  def test_should_return_true_with_supported_property_getter_and_value
-    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
-    assert  answer.created_on?
-  end
-
-  def test_should_return_false_with_not_supported_property_exists
-    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
-    assert !answer.updated_on?
-  end
-
-  def test_should_return_false_with_not_implemented_property_exists
-    answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.parser.fake")])
-    assert !answer.expires_on?
-  end
-
-end