whois 0.5.3 → 0.8.0

data/test/answer/parser/whois_publicinterestregistry_net_test.rb

@@ -0,0 +1,210 @@
+require 'test_helper'
+require 'whois/answer/parser/whois.publicinterestregistry.net'
+
+class AnswerParserWhoisPublicinterestregistryNetTest < Test::Unit::TestCase
+
+  TESTCASE_PATH = File.expand_path(File.dirname(__FILE__) + '/../../testcases/responses/whois.publicinterestregistry.net')
+
+  def setup
+    @klass  = Whois::Answer::Parser::WhoisPublicinterestregistryNet
+    @host   = "whois.publicinterestregistry.net"
+  end
+
+
+  def test_disclaimer
+    expected = <<-EOS.strip
+NOTICE: Access to .ORG WHOIS information is provided to assist persons in \
+determining the contents of a domain name registration record in the Public Interest Registry \
+registry database. The data in this record is provided by Public Interest Registry \
+for informational purposes only, and Public Interest Registry does not guarantee its \
+accuracy.  This service is intended only for query-based access.  You agree \
+that you will use this data only for lawful purposes and that, under no \
+circumstances will you use this data to: (a) allow, enable, or otherwise \
+support the transmission by e-mail, telephone, or facsimile of mass \
+unsolicited, commercial advertising or solicitations to entities other than \
+the data recipient's own existing customers; or (b) enable high volume, \
+automated, electronic processes that send queries or data to the systems of \
+Registry Operator or any ICANN-Accredited Registrar, except as reasonably \
+necessary to register domain names or modify existing registrations.  All \
+rights reserved. Public Interest Registry reserves the right to modify these terms at any \
+time. By submitting this query, you agree to abide by this policy.
+    EOS
+    assert_equal  expected,
+                  @klass.new(load_part('/registered.txt')).disclaimer
+  end
+
+  def test_disclaimer_with_available
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).disclaimer
+  end
+
+
+  def test_domain
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).domain
+    assert_equal  "google.org",
+                  @klass.new(load_part('/registered.txt')).domain
+  end
+
+  def test_domain_id
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).domain_id
+    assert_equal  "D2244233-LROR",
+                  @klass.new(load_part('/registered.txt')).domain_id
+  end
+
+
+  def test_status
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).status
+    assert_equal  ["CLIENT DELETE PROHIBITED", "CLIENT TRANSFER PROHIBITED", "CLIENT UPDATE PROHIBITED"],
+                  @klass.new(load_part('/registered.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('/available.txt')).registered?
+    assert  @klass.new(load_part('/registered.txt')).registered?
+  end
+
+
+  def test_created_on
+    assert_equal  Time.parse("21-Oct-1998 04:00:00 UTC"),
+                  @klass.new(load_part('/registered.txt')).created_on
+  end
+
+  def test_created_on_with_available
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).created_on
+  end
+
+  def test_updated_on
+    assert_equal  Time.parse("04-Mar-2009 12:07:19 UTC"),
+                  @klass.new(load_part('/registered.txt')).updated_on
+  end
+
+  def test_updated_on_with_available
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).updated_on
+  end
+
+  def test_expires_on
+    assert_equal  Time.parse("20-Oct-2012 04:00:00 UTC"),
+                  @klass.new(load_part('/registered.txt')).expires_on
+  end
+
+  def test_expires_on_with_available
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).expires_on
+  end
+
+
+  def test_registrar
+    registrar = @klass.new(load_part('/registered.txt')).registrar
+    assert_instance_of Whois::Answer::Registrar, registrar
+    assert_equal "R37-LROR", registrar.id
+    assert_equal "MarkMonitor Inc.", registrar.name
+    assert_equal nil, registrar.organization
+  end
+
+  def test_registrar_with_available
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).registrar
+  end
+
+
+  def test_registrant
+    contact = @klass.new(load_part('/registered.txt')).registrant
+    assert_instance_of Whois::Answer::Contact, contact
+    assert_equal "mmr-32097", contact.id
+    assert_equal "DNS Admin", contact.name
+    assert_equal "Google Inc.", contact.organization
+    assert_equal "1600 Amphitheatre Parkway", contact.address
+    assert_equal "Mountain View", contact.city
+    assert_equal "CA", contact.state
+    assert_equal "94043", contact.zip
+    assert_equal nil, contact.country
+    assert_equal "US", contact.country_code
+    assert_equal "+1.6506234000", contact.phone
+    assert_equal "+1.6506188571", contact.fax
+    assert_equal "dns-admin@google.com", contact.email
+  end
+
+  def test_registrant_with_available
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).registrant
+  end
+
+
+  def test_admin
+    contact = @klass.new(load_part('/registered.txt')).admin
+    assert_instance_of Whois::Answer::Contact, contact
+    assert_equal "mmr-32097", contact.id
+    assert_equal "DNS Admin", contact.name
+    assert_equal "Google Inc.", contact.organization
+    assert_equal "1600 Amphitheatre Parkway", contact.address
+    assert_equal "Mountain View", contact.city
+    assert_equal "CA", contact.state
+    assert_equal "94043", contact.zip
+    assert_equal nil, contact.country
+    assert_equal "US", contact.country_code
+    assert_equal "+1.6506234000", contact.phone
+    assert_equal "+1.6506188571", contact.fax
+    assert_equal "dns-admin@google.com", contact.email
+  end
+
+  def test_admin_with_available
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).admin
+  end
+
+
+  def test_technical
+    contact = @klass.new(load_part('/registered.txt')).technical
+    assert_instance_of Whois::Answer::Contact, contact
+    assert_equal "mmr-32097", contact.id
+    assert_equal "DNS Admin", contact.name
+    assert_equal "Google Inc.", contact.organization
+    assert_equal "1600 Amphitheatre Parkway", contact.address
+    assert_equal "Mountain View", contact.city
+    assert_equal "CA", contact.state
+    assert_equal "94043", contact.zip
+    assert_equal nil, contact.country
+    assert_equal "US", contact.country_code
+    assert_equal "+1.6506234000", contact.phone
+    assert_equal "+1.6506188571", contact.fax
+    assert_equal "dns-admin@google.com", contact.email
+  end
+
+  def test_technical_with_available
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).technical
+  end
+
+
+  def test_nameservers
+    assert_equal  %w(ns2.google.com ns1.google.com ns3.google.com ns4.google.com),
+                  @klass.new(load_part('/registered.txt')).nameservers
+  end
+
+  def test_nameservers_with_available
+    assert_equal  nil,
+                  @klass.new(load_part('/available.txt')).nameservers
+  end
+
+
+  protected
+
+    def load_part(path)
+      part(File.read(TESTCASE_PATH + path), @host)
+    end
+
+    def part(*args)
+      Whois::Answer::Part.new(*args)
+    end
+
+end

data/test/answer/parser_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+class AnswerParserTest < Test::Unit::TestCase
+
+  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_should_not_create_parser_instance_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_should_create_parser_instance_with_supported_server
+    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_should_create_blank_parser_instance_with_not_supported_server
+    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
+
+  
+  (Whois::Answer::Parser.registrable_methods - [:referral_url, :referral_whois]).each do |method|
+    define_method "test_should_delegate_#{method}_to_parsers_first_parser_if_supported" do
+      answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "whois.nic.it")])
+      parser = @klass.new(answer)
+      parser.parsers.first.expects(method).returns(:value)
+      assert_equal :value, parser.send(method)
+    end
+  end
+
+  [:referral_url, :referral_whois].each do |method|
+    define_method "test_should_delegate_#{method}_to_parsers_raise_unless_supported" do
+      answer = Whois::Answer.new(nil, [Whois::Answer::Part.new("", "whois.nic.it")])
+      parser = @klass.new(answer)
+      assert_raise(Whois::PropertyNotSupported) { parser.send(method) }
+    end
+  end
+
+  Whois::Answer::Parser.registrable_methods.each do |method|
+    define_method "test_should_delegate_#{method}_to_parser_raise_with_no_zero_parts" do
+      answer = Whois::Answer.new(nil, [])
+      parser = @klass.new(answer)
+      assert_raise(Whois::ParserError) { parser.send(method) }
+    end
+  end
+
+  def test_should_not_delegate_unallowed_method_to_parser
+    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
+
+end

data/test/answer_test.rb

@@ -0,0 +1,99 @@
+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_equality_check_self
+    assert_equal      @answer, @answer
+    assert  @answer.eql?(@answer)
+  end
+
+  def test_equality_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_match?
+    assert  @answer.match?(/domain\.foo/)
+    assert !@answer.match?(/google/)
+  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
+
+  Whois::Answer::Parser.registrable_methods.each do |method|
+    define_method "test_should_delegate_#{method}_to_parser" do
+      answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.nic.it")])
+      parser = answer.parser
+      parser.expects(method).returns(:value)
+      assert_equal :value, answer.send(method)
+    end
+  end
+
+end

data/test/client_test.rb

@@ -76,9 +76,9 @@ class ClientTest < Test::Unit::TestCase
   need_connectivity do
 
     def test_query_with_domain
-      response = @client.query("weppos.it")
-      assert_match /Domain:\s+weppos\.it/, response
-      assert_match /Created:/, response
+      answer = @client.query("weppos.it")
+      assert answer.match?(/Domain:\s+weppos\.it/)
+      assert answer.match?(/Created:/)
     end
 
   end

data/test/integration_test.rb

@@ -0,0 +1,31 @@
+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/{adapters → server/adapters}/afilias_test.rb

@@ -1,11 +1,10 @@
 require 'test_helper'
 
 class ServerAdaptersAfiliasTest < Test::Unit::TestCase
-  include Whois
 
   def setup
     @definition = [:tld, ".foo", "whois.foo", {}]
-    @klass = Server::Adapters::Afilias
+    @klass  = Whois::Server::Adapters::Afilias
     @server = @klass.new(*@definition)
   end
 
@@ -13,16 +12,22 @@ class ServerAdaptersAfiliasTest < Test::Unit::TestCase
     response = "No match for DOMAIN.FOO."
     expected = response
     @server.expects(:ask_the_socket).with("domain.foo", "whois.afilias-grs.info", 43).returns(response)
-    assert_equal expected, @server.query("domain.foo")
+    assert_equal expected,
+                 @server.query("domain.foo").to_s
+    assert_equal [Whois::Answer::Part.new(response, "whois.afilias-grs.info")],
+                 @server.buffer
   end
 
   def test_query_with_referral
-    referral = File.read(File.dirname(__FILE__) + "/../testcases/referrals/afilias.bz.txt")
+    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)
-    assert_equal expected, @server.query("domain.foo")
+    assert_equal expected,
+                 @server.query("domain.foo").to_s
+    assert_equal [Whois::Answer::Part.new(referral, "whois.afilias-grs.info"), Whois::Answer::Part.new(response, "whois.belizenic.bz")],
+                 @server.buffer
   end
 
 end