whois 1.2.2 → 1.3.0

data/test/whois/client_test.rb

@@ -1,96 +0,0 @@
-require 'test_helper'
-
-class ClientTest < Test::Unit::TestCase
-
-  def setup
-    @client = Whois::Client.new
-  end
-
-
-  def test_initialize
-    client = Whois::Client.new
-    assert_instance_of Whois::Client, client
-  end
-
-  def test_initialize_with_timeout
-    client = Whois::Client.new(:timeout => 100)
-    assert_equal 100, client.timeout
-  end
-
-  def test_initialize_with_block
-    Whois::Client.new do |client|
-      assert_instance_of Whois::Client, client
-    end
-  end
-
-
-  def test_query_should_cast_qstring_to_string
-    server = Object.new
-    # I can't use the String because Array#to_s behaves differentl
-    # on Ruby 1.8.7 and Ruby 1.9.1
-    # http://redmine.ruby-lang.org/issues/show/2617
-    server.expects(:query).with(instance_of(String))
-    Whois::Server.expects(:guess).with(instance_of(String)).returns(server)
-    @client.query(["google", ".", "com"])
-  end
-
-  def test_query_with_email_address_should_raise
-    assert_raise(Whois::ServerNotSupported) { @client.query("weppos@weppos.net") }
-  end
-
-  def test_query_with_domain_with_no_whois
-    error = assert_raise(Whois::NoInterfaceError) { @client.query("weppos.ad") }
-    assert_match /no whois server/, error.message
-  end
-
-  def test_query_with_domain_with_web_whois
-    error = assert_raise(Whois::WebInterfaceError) { @client.query("weppos.ar") }
-    assert_match /no whois server/, error.message
-    assert_match /www\.nic\.ar/, error.message
-  end
-
-  def test_query_with_timeout
-    server = Class.new do
-      def query(*args)
-        sleep(2)
-      end
-    end
-    Whois::Server.expects(:guess).returns(server.new)
-    @client.timeout = 1
-    assert_raise(Timeout::Error) { @client.query("foo.com") }
-  end
-
-  def test_query_with_unlimited_timeout
-    server = Class.new do
-      def query(*args)
-        sleep(1)
-      end
-    end
-    Whois::Server.expects(:guess).returns(server.new)
-    @client.timeout = nil
-    assert_nothing_raised { @client.query("foo.com") }
-  end
-
-  def test_query_within_timeout
-    server = Class.new do
-      def query(*args)
-        sleep(1)
-      end
-    end
-    Whois::Server.expects(:guess).returns(server.new)
-    @client.timeout = 5
-    assert_nothing_raised { @client.query("foo.com") }
-  end
-
-
-  need_connectivity do
-
-    def test_query_with_domain
-      answer = @client.query("weppos.it")
-      assert answer.match?(/Domain:\s+weppos\.it/)
-      assert answer.match?(/Created:/)
-    end
-
-  end
-
-end

data/test/whois/errors_test.rb

@@ -1,23 +0,0 @@
-require 'test_helper'
-
-class WebInterfaceErrorTest < Test::Unit::TestCase
-
-  def setup
-    @klass = Whois::WebInterfaceError
-  end
-
-  def test_url
-    assert_raise(ArgumentError) { @klass.new }
-  end
-
-  def test_url
-    error = @klass.new("http://example.com")
-    assert_equal "http://example.com", error.url
-  end
-
-  def test_message
-    error = @klass.new("http://example.com")
-    assert_match %r{http://example.com}, error.message
-  end
-
-end

data/test/whois/integration_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-
-class IntegrationTest < Test::Unit::TestCase
-
-  def test_should_query_domain_get_answer_load_parser_parse_response_and_return_boolean
-    Whois::Server.define(:tld, ".it", "whois.nic.it")
-    response = <<-EOS
-Domain:             google.it
-Status:             AVAILABLE
-    EOS
-
-    Whois::Server::Adapters::Standard.any_instance.expects(:query_the_socket).with("google.it", "whois.nic.it").returns(response)
-    assert Whois.available?("google.it")
-  end
-
-  def test_should_query_domain_get_answer_load_parser_parse_response
-    Whois::Server.define(:tld, ".it", "whois.nic.it")
-    response = <<-EOS
-Domain:             google.it
-Status:             AVAILABLE
-    EOS
-
-    Whois::Server::Adapters::Standard.any_instance.expects(:query_the_socket).with("google.it", "whois.nic.it").returns(response)
-    answer = Whois.query("google.it")
-    assert_instance_of Whois::Answer, answer
-    assert answer.available?
-    assert_instance_of Whois::Answer::Parser, answer.parser
-    assert_instance_of Whois::Answer::Parser::WhoisNicIt, answer.parser.parsers.first
-  end
-
-end

data/test/whois/server/adapters/afilias_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-class ServerAdaptersAfiliasTest < Test::Unit::TestCase
-
-  def setup
-    @definition = [:tld, ".foo", "whois.foo", {}]
-    @klass  = Whois::Server::Adapters::Afilias
-    @server = @klass.new(*@definition)
-  end
-
-  def test_query
-    response = "No match for DOMAIN.FOO."
-    expected = response
-    @server.expects(:ask_the_socket).with("domain.foo", "whois.afilias-grs.info", 43).returns(response)
-    answer   = @server.query("domain.foo")
-
-    assert_equal response,
-                 answer.to_s
-    assert_equal [Whois::Answer::Part.new(response, "whois.afilias-grs.info")],
-                 answer.parts
-  end
-
-  def test_query_with_referral
-    referral = File.read(File.dirname(__FILE__) + "/../../../testcases/referrals/afilias.bz.txt")
-    response = "Match for DOMAIN.FOO."
-    expected = referral + "\n" + response
-    @server.expects(:ask_the_socket).with("domain.foo", "whois.afilias-grs.info", 43).returns(referral)
-    @server.expects(:ask_the_socket).with("domain.foo", "whois.belizenic.bz", 43).returns(response)
-    answer   = @server.query("domain.foo")
-
-    assert_equal expected,
-                 answer.to_s
-    assert_equal [Whois::Answer::Part.new(referral, "whois.afilias-grs.info"), Whois::Answer::Part.new(response, "whois.belizenic.bz")],
-                 answer.parts
-  end
-
-end

data/test/whois/server/adapters/base_test.rb

@@ -1,15 +0,0 @@
-require 'test_helper'
-
-class ServerAdaptersBaseTest < Test::Unit::TestCase
-
-  def setup
-    @definition = [:tld, ".foo", "whois.foo", {}]
-    @klass  = Whois::Server::Adapters::Base
-    @server = @klass.new(*@definition)
-  end
-
-  def test_query_should_raise
-    assert_raise(NotImplementedError) { @server.query("example.com") }
-  end
-
-end

data/test/whois/server/adapters/formatted_test.rb

@@ -1,29 +0,0 @@
-require 'test_helper'
-
-class ServerAdaptersFormattedTest < Test::Unit::TestCase
-
-  def setup
-    @definition = [:tld, ".de", "whois.denic.de", {:format => "-T dn,ace -C US-ASCII %s"}]
-    @klass  = Whois::Server::Adapters::Formatted
-    @server = @klass.new(*@definition)
-  end
-
-  def test_query
-    response = "Whois Response"
-    expected = response
-    @server.expects(:ask_the_socket).with("-T dn,ace -C US-ASCII domain.foo", "whois.denic.de", 43).returns(response)
-    answer = @server.query("domain.foo")
-
-    assert_equal expected,
-                 answer.to_s
-    assert_equal [Whois::Answer::Part.new(response, "whois.denic.de")],
-                 answer.parts
-  end
-
-  def test_query_should_raise_without_option_format
-    @server = @klass.new(*[:tld, ".de", "whois.denic.de", {}])
-    @server.expects(:ask_the_socket).never
-    assert_raise(Whois::ServerError) { @server.query("domain.foo") }
-  end
-
-end

data/test/whois/server/adapters/none_test.rb

@@ -1,22 +0,0 @@
-require 'test_helper'
-
-class ServerAdaptersNoneTest < Test::Unit::TestCase
-  include Whois
-
-  def setup
-    @klass = Server::Adapters::None
-  end
-
-  def test_query
-    @server = @klass.new(:tld, ".foo", nil, {})
-    error = assert_raise(NoInterfaceError) { @server.query("domain.foo") }
-    assert_match /tld/, error.message
-  end
-
-  def test_query_with_ipv4
-    @server = @klass.new(:ipv4, "127.0.0.1", nil, {})
-    error = assert_raise(NoInterfaceError) { @server.query("domain.foo") }
-    assert_match /ipv4/, error.message
-  end
-
-end

data/test/whois/server/adapters/not_implemented_test.rb

@@ -1,16 +0,0 @@
-require 'test_helper'
-
-class ServerAdaptersNotImplementedTest < Test::Unit::TestCase
-  include Whois
-
-  def setup
-    @definition = [:tld, ".foo", nil, {}]
-    @klass = Server::Adapters::NotImplemented
-    @server = @klass.new(*@definition)
-  end
-
-  def test_query
-    assert_raise(ServerNotImplemented) { @server.query("domain.foo") }
-  end
-
-end

data/test/whois/server/adapters/pir_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-class ServerAdaptersPirTest < Test::Unit::TestCase
-
-  def setup
-    @definition = [:tld, ".foo", "whois.foo", {}]
-    @klass  = Whois::Server::Adapters::Pir
-    @server = @klass.new(*@definition)
-  end
-
-  def test_query
-    response = "No match for DOMAIN.FOO."
-    expected = response
-    @server.expects(:ask_the_socket).with("FULL domain.foo", "whois.publicinterestregistry.net", 43).returns(response)
-    answer = @server.query("domain.foo")
-
-    assert_equal expected,
-                 answer.to_s
-    assert_equal [Whois::Answer::Part.new(response, "whois.publicinterestregistry.net")],
-                 answer.parts
-  end
-
-  def test_query_with_referral
-    referral = File.read(File.dirname(__FILE__) + "/../../../testcases/referrals/pir.org.txt")
-    response = "Match for DOMAIN.FOO."
-    expected = referral + "\n" + response
-    @server.expects(:ask_the_socket).with("FULL domain.foo", "whois.publicinterestregistry.net", 43).returns(referral)
-    @server.expects(:ask_the_socket).with("domain.foo", "whois.iana.org", 43).returns(response)
-    answer = @server.query("domain.foo")
-
-    assert_equal expected,
-                 answer.to_s
-    assert_equal [Whois::Answer::Part.new(referral, "whois.publicinterestregistry.net"), Whois::Answer::Part.new(response, "whois.iana.org")], 
-                 answer.parts
-  end
-
-end

data/test/whois/server/adapters/standard_test.rb

@@ -1,36 +0,0 @@
-require 'test_helper'
-
-class ServerAdaptersStandardTest < Test::Unit::TestCase
-
-  def setup
-    @definition = [:tld, ".foo", "whois.foo", {}]
-    @klass  = Whois::Server::Adapters::Standard
-    @server = @klass.new(*@definition)
-  end
-
-  def test_query
-    response = "Whois Response"
-    expected = response
-    @server.expects(:ask_the_socket).with("domain.foo", "whois.foo", 43).returns(response)
-    answer = @server.query("domain.foo")
-
-    assert_equal expected,
-                 answer.to_s
-    assert_equal [Whois::Answer::Part.new(response, "whois.foo")],
-                 answer.parts
-  end
-
-  def test_query_with_port
-    response = "Whois Response"
-    expected = response
-    @server = @klass.new(:tld, ".foo", "whois.foo", { :port => 20 })
-    @server.expects(:ask_the_socket).with("domain.foo", "whois.foo", 20).returns(response)
-    answer = @server.query("domain.foo")
-
-    assert_equal expected,
-                 answer.to_s
-    assert_equal [Whois::Answer::Part.new(response, "whois.foo")],
-                 answer.parts
-  end
-
-end

data/test/whois/server/adapters/verisign_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-class ServerAdaptersVerisignTest < Test::Unit::TestCase
-
-  def setup
-    @definition = [:tld, ".foo", "whois.foo", {}]
-    @klass  = Whois::Server::Adapters::Verisign
-    @server = @klass.new(*@definition)
-  end
-
-  def test_query
-    response = "No match for DOMAIN.FOO."
-    expected = response
-    @server.expects(:ask_the_socket).with("=domain.foo", "whois.foo", 43).returns(response)
-    answer = @server.query("domain.foo")
-
-    assert_equal expected,
-                 answer.to_s
-    assert_equal [Whois::Answer::Part.new(response, "whois.foo")],
-                 answer.parts
-  end
-
-  def test_query_with_referral
-    referral = File.read(File.dirname(__FILE__) + "/../../../testcases/referrals/crsnic.com.txt")
-    response = "Match for DOMAIN.FOO."
-    expected = referral + "\n" + response
-    @server.expects(:ask_the_socket).with("=domain.foo", "whois.foo", 43).returns(referral)
-    @server.expects(:ask_the_socket).with("domain.foo", "whois.markmonitor.com", 43).returns(response)
-    answer = @server.query("domain.foo")
-
-    assert_equal expected,
-                 answer.to_s
-    assert_equal [Whois::Answer::Part.new(referral, "whois.foo"), Whois::Answer::Part.new(response, "whois.markmonitor.com")],
-                 answer.parts
-  end
-  
-  def test_query_with_referral_should_extract_the_closest_referral_server_with_more_servers
-    referral = File.read(File.dirname(__FILE__) + "/../../../testcases/referrals/crsnic.com_more_servers.txt")
-    @server.expects(:ask_the_socket).with("=domain.foo", "whois.foo", 43).returns(referral)
-    @server.expects(:ask_the_socket).with("domain.foo", "whois.markmonitor.com", 43).returns("")
-    assert @server.query("domain.foo")
-  end
-  
-  def test_query_with_referral_should_extract_the_closest_referral_server_with_more_servers
-    referral = File.read(File.dirname(__FILE__) + "/../../../testcases/referrals/crsnic.com_one_server.txt")
-    @server.expects(:ask_the_socket).with("=domain.foo", "whois.foo", 43).returns(referral)
-    @server.expects(:ask_the_socket).with("domain.foo", "whois.godaddy.com", 43).returns("")
-    assert @server.query("domain.foo")
-  end
-
-end

data/test/whois/server/adapters/web_test.rb

@@ -1,17 +0,0 @@
-require 'test_helper'
-
-class ServerAdaptersWebTest < Test::Unit::TestCase
-  include Whois
-
-  def setup
-    @definition = [:tld, ".foo", nil, { :web => "http://whois.foo" }]
-    @klass = Server::Adapters::Web
-    @server = @klass.new(*@definition)
-  end
-
-  def test_query
-    error = assert_raise(WebInterfaceError) { @server.query("domain.foo") }
-    assert_match /whois\.foo/, error.message
-  end
-
-end

data/test/whois/server_test.rb

@@ -1,105 +0,0 @@
-require 'test_helper'
-
-class ServerTest < Test::Unit::TestCase
-
-  def setup
-    Whois::Server.class_eval { class_variable_set("@@definitions", { :tld => [], :ipv4 =>[], :ipv6 => [] }) }  
-  end
-
- 
-  def test_guess_should_recognize_email
-    Whois::Server.expects(:find_for_email).with("email@example.org").returns(true)
-    assert Whois::Server.guess("email@example.org")
-  end
-
-  def test_guess_should_recognize_tld
-    Whois::Server.expects(:find_for_tld).with("google.com").returns(true)
-    assert Whois::Server.guess("google.com")
-  end
-
-  def test_guess_should_recognize_ipv4
-    Whois::Server.expects(:find_for_ipv4).with("192.168.1.1").returns(true)
-    assert Whois::Server.guess("192.168.1.1")
-  end
-
-  def test_guess_should_recognize_ipv6
-    Whois::Server.expects(:find_for_ipv6).with("2001:0db8:85a3:0000:0000:8a2e:0370:7334").returns(true)
-    assert Whois::Server.guess("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
-  end
-
-  def test_guess_should_recognize_ipv6_with_zeros_group
-    Whois::Server.expects(:find_for_ipv6).with("2002::1").returns(true)
-    assert Whois::Server.guess("2002::1")
-  end
-
-  def test_guess_should_raise_servernotfound_with_unrecognized_query
-    assert_raise(Whois::ServerNotFound){ Whois::Server.guess("xyz") }
-  end
-
-
-  def test_find_for_tld_should_not_consider_dot_as_regexp_instruction
-    Whois::Server.define(:tld, ".no.com", "whois.no.com")
-    Whois::Server.define(:tld, ".com", "whois.com")
-    assert_equal "whois.com", Whois::Server.guess("antoniocangiano.com").host
-  end
-
-  def test_find_for_ipv6_should_factory_ipv6_with_ipv4_compatibility
-    Whois::Server.define(:ipv6, "::192.168.1.1", "whois.foo")
-    Whois::Server.expects(:factory).with(:ipv6, any_parameters).returns(true)
-    assert Whois::Server.guess("::192.168.1.1")
-  end
-
-  def test_guess_should_raise_servernotfound_with_unrecognized_query
-    assert_raise(Whois::ServerNotFound) { Whois::Server.guess("xyz") }
-  end
-
-
-  def test_definitions
-    assert_instance_of Hash, Whois::Server.definitions
-  end
-
-  def test_definitions_with_key
-    assert_equal nil, Whois::Server.definitions(:foo)
-    Whois::Server.define(:foo, ".foo", "whois.foo")
-    assert_equal [[".foo", "whois.foo", {}]], Whois::Server.definitions(:foo)
-  end
-
-
-  def test_define_tld
-    Whois::Server.define(:tld, ".foo", "whois.foo")
-    assert_equal [".foo", "whois.foo", {}], Whois::Server.definitions[:tld].last
-  end
-
-  def test_define_tld_with_options
-    Whois::Server.define(:tld, ".foo", "whois.foo", :foo => "bar")
-    assert_equal [".foo", "whois.foo", { :foo => "bar" }], Whois::Server.definitions[:tld].last
-  end
-
-  def test_define_ipv4
-    Whois::Server.define(:ipv4, ".foo", "whois.foo")
-    assert_equal [".foo", "whois.foo", {}], Whois::Server.definitions[:ipv4].last
-  end
-
-  def test_define_ipv4_with_options
-    Whois::Server.define(:ipv4, ".foo", "whois.foo", :foo => "bar")
-    assert_equal [".foo", "whois.foo", { :foo => "bar" }], Whois::Server.definitions[:ipv4].last
-  end
-
-
-  def test_factory
-    server = Whois::Server.factory(:tld, ".foo", "whois.foo")
-    assert_instance_of Whois::Server::Adapters::Standard, server
-  end
-
-  def test_factory_with_adapter
-    server = Whois::Server.factory(:tld, ".foo", "whois.foo", :adapter => Whois::Server::Adapters::None)
-    assert_instance_of Whois::Server::Adapters::None, server
-  end
-
-  def test_factory_with_adapter_should_delete_adapter_option
-    server = Whois::Server.factory(:tld, ".foo", "whois.foo", :adapter => Whois::Server::Adapters::None, :foo => "bar")
-    assert_equal server.options, { :foo => "bar" } 
-  end
-
-
-end