whois 1.0.12 → 1.1.0

data/test/answer/parser/whois.nic.it_test.rb

@@ -90,79 +90,106 @@ class AnswerParserWhoisNicItTest < Whois::Answer::Parser::TestCase
   end
 
 
-  def test_contact
-    contact = @klass.new(load_part('/contact.txt')).registrant
-    assert_instance_of Whois::Answer::Contact, contact
-    assert_equal "HTML1-ITNIC", contact.id
-    assert_equal "HTML.it srl", contact.name
-    assert_equal "HTML.it srl", contact.organization
-    assert_equal "Viale Alessandrino, 595", contact.address
-    assert_equal "Roma", contact.city
-    assert_equal "00172", contact.zip
-    assert_equal nil, contact.country
-    assert_equal "IT", contact.country_code
-    assert_equal Time.parse("2007-03-01 10:28:08"), contact.created_on
-    assert_equal Time.parse("2007-03-01 10:28:08"), contact.updated_on
-  end
-
-  def test_registrant
-    contact = @klass.new(load_part('/registered.txt')).registrant
-    assert_instance_of Whois::Answer::Contact, contact
-    assert_equal "GOOG175-ITNIC", contact.id
-    assert_equal "Google Ireland Holdings", contact.name
-    assert_equal nil, contact.organization
-    assert_equal "30 Herbert Street", contact.address
-    assert_equal "Dublin", contact.city
-    assert_equal "2", contact.zip
-    assert_equal nil, contact.country
-    assert_equal "IE", contact.country_code
-    assert_equal Time.parse("2008-11-27 16:47:22"), contact.created_on
-    assert_equal Time.parse("2008-11-27 16:47:22"), contact.updated_on
-  end
-
-  def test_registrant_with_available
-    assert_equal  nil,
-                  @klass.new(load_part('/available.txt')).registrant
+  def test_registrant_contact_with_registered
+    parser    = @klass.new(load_part('/registered.txt'))
+    expected  = parser.registrant_contact
+    assert_equal  expected, parser.registrant_contact
+    assert_equal  expected, parser.instance_eval { @registrant_contact }
+
+    assert_instance_of Whois::Answer::Contact, expected
+    assert_equal "GOOG175-ITNIC", expected.id
   end
 
-  def test_admin
-    contact = @klass.new(load_part('/registered.txt')).admin
-    assert_instance_of Whois::Answer::Contact, contact
-    assert_equal "TT4277-ITNIC", contact.id
-    assert_equal "Tsao Tu", contact.name
-    assert_equal "Tu Tsao", contact.organization
-    assert_equal "30 Herbert Street", contact.address
-    assert_equal "Dublin", contact.city
-    assert_equal "2", contact.zip
-    assert_equal nil, contact.country
-    assert_equal "IE", contact.country_code
-    assert_equal Time.parse("2008-11-27 16:47:22"), contact.created_on
-    assert_equal Time.parse("2008-11-27 16:47:22"), contact.updated_on
+  def test_registrant_contact_with_available
+    parser    = @klass.new(load_part('/available.txt'))
+    expected  = nil
+    assert_equal  expected, parser.registrant_contact
+    assert_equal  expected, parser.instance_eval { @registrant_contact }
   end
 
-  def test_admin_with_available
-    assert_equal  nil,
-                  @klass.new(load_part('/available.txt')).admin
+  def test_registrant_contact
+    parser    = @klass.new(load_part('/property_registrant_contact.txt'))
+    result    = parser.registrant_contact
+
+    assert_instance_of Whois::Answer::Contact,      result
+    assert_equal "HTML1-ITNIC",                     result.id
+    assert_equal "HTML.it srl",                     result.name
+    assert_equal "HTML.it srl",                     result.organization
+    assert_equal "Viale Alessandrino, 595",         result.address
+    assert_equal "Roma",                            result.city
+    assert_equal "00172",                           result.zip
+    assert_equal nil,                               result.country
+    assert_equal "IT",                              result.country_code
+    assert_equal Time.parse("2007-03-01 10:28:08"), result.created_on
+    assert_equal Time.parse("2007-03-01 10:28:08"), result.updated_on
   end
 
-  def test_technical
-    contact = @klass.new(load_part('/registered.txt')).technical
-    assert_instance_of Whois::Answer::Contact, contact
-    assert_equal "TS7016-ITNIC", contact.id
-    assert_equal "Technical Services", contact.name
-    assert_equal nil, contact.organization
-    assert_equal nil, contact.address
-    assert_equal nil, contact.city
-    assert_equal nil, contact.zip
-    assert_equal nil, contact.country
-    assert_equal nil, contact.country_code
-    assert_equal nil, contact.created_on
-    assert_equal nil, contact.updated_on
+  def test_admin_contact_with_registered
+    parser    = @klass.new(load_part('/registered.txt'))
+    expected  = parser.admin_contact
+    assert_equal  expected, parser.admin_contact
+    assert_equal  expected, parser.instance_eval { @admin_contact }
+
+    assert_instance_of Whois::Answer::Contact, expected
+    assert_equal "TT4277-ITNIC", expected.id
   end
 
-  def test_technical_with_available
-    assert_equal  nil,
-                  @klass.new(load_part('/available.txt')).technical
+  def test_admin_contact_with_available
+    parser    = @klass.new(load_part('/available.txt'))
+    expected  = nil
+    assert_equal  expected, parser.admin_contact
+    assert_equal  expected, parser.instance_eval { @admin_contact }
+  end
+
+  def test_admin_contact
+    parser    = @klass.new(load_part('/property_admin_contact.txt'))
+    result    = parser.admin_contact
+
+    assert_instance_of Whois::Answer::Contact,      result
+    assert_equal "TT4277-ITNIC",                    result.id
+    assert_equal "Tsao Tu",                         result.name
+    assert_equal "Tu Tsao",                         result.organization
+    assert_equal "30 Herbert Street",               result.address
+    assert_equal "Dublin",                          result.city
+    assert_equal "2",                               result.zip
+    assert_equal nil,                               result.country
+    assert_equal "IE",                              result.country_code
+    assert_equal Time.parse("2008-11-27 16:47:22"), result.created_on
+    assert_equal Time.parse("2008-11-27 16:47:22"), result.updated_on
+  end
+
+  def test_technical_contact_with_registered
+    parser    = @klass.new(load_part('/registered.txt'))
+    expected  = parser.technical_contact
+    assert_equal  expected, parser.technical_contact
+    assert_equal  expected, parser.instance_eval { @technical_contact }
+
+    assert_instance_of Whois::Answer::Contact, expected
+    assert_equal "TS7016-ITNIC", expected.id
+  end
+
+  def test_technical_contact_with_available
+    parser    = @klass.new(load_part('/available.txt'))
+    expected  = nil
+    assert_equal  expected, parser.technical_contact
+    assert_equal  expected, parser.instance_eval { @technical_contact }
+  end
+
+  def test_technical_contact
+    parser    = @klass.new(load_part('/property_technical_contact.txt'))
+    result    = parser.technical_contact
+
+    assert_instance_of Whois::Answer::Contact,  result
+    assert_equal "TS7016-ITNIC",                result.id
+    assert_equal "Technical Services",          result.name
+    assert_equal nil,                           result.organization
+    assert_equal nil,                           result.address
+    assert_equal nil,                           result.city
+    assert_equal nil,                           result.zip
+    assert_equal nil,                           result.country
+    assert_equal nil,                           result.country_code
+    assert_equal nil,                           result.created_on
+    assert_equal nil,                           result.updated_on
   end
 
 

data/test/answer/parser/whois.nic.st_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+require 'whois/answer/parser/whois.nic.st'
+
+class AnswerParserWhoisNicStTest < Whois::Answer::Parser::TestCase
+
+  def setup
+    @klass  = Whois::Answer::Parser::WhoisNicSt
+    @host   = "whois.nic.st"
+  end
+
+
+  def test_status
+    parser    = @klass.new(load_part('/registered.txt'))
+    expected  = :registered
+    assert_equal  expected, parser.status
+    assert_equal  expected, parser.instance_eval { @status }
+
+    parser    = @klass.new(load_part('/available.txt'))
+    expected  = :available
+    assert_equal  expected, parser.status
+    assert_equal  expected, parser.instance_eval { @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
+    parser    = @klass.new(load_part('/registered.txt'))
+    expected  = Time.parse("2004-06-15")
+    assert_equal  expected, parser.created_on
+    assert_equal  expected, parser.instance_eval { @created_on }
+
+    parser    = @klass.new(load_part('/available.txt'))
+    expected  = nil
+    assert_equal  expected, parser.created_on
+    assert_equal  expected, parser.instance_eval { @created_on }
+  end
+
+  def test_updated_on
+    parser    = @klass.new(load_part('/registered.txt'))
+    expected  = Time.parse("2009-05-18")
+    assert_equal  expected, parser.updated_on
+    assert_equal  expected, parser.instance_eval { @updated_on }
+
+    parser    = @klass.new(load_part('/available.txt'))
+    expected  = nil
+    assert_equal  expected, parser.updated_on
+    assert_equal  expected, parser.instance_eval { @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( ns1.google.com ns2.google.com ns3.google.com ns4.google.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/answer/parser/whois.publicinterestregistry.net_test.rb

@@ -92,7 +92,7 @@ time. By submitting this query, you agree to abide by this policy.
   end
 
 
-  def test_registrar
+  def test_registrar_with_registered
     registrar = @klass.new(load_part('/registered.txt')).registrar
     assert_instance_of Whois::Answer::Registrar, registrar
     assert_equal "R37-LROR", registrar.id
@@ -101,13 +101,15 @@ time. By submitting this query, you agree to abide by this policy.
   end
 
   def test_registrar_with_available
-    assert_equal  nil,
-                  @klass.new(load_part('/available.txt')).registrar
+    parser      = @klass.new(load_part('/available.txt'))
+    expected    = nil
+    assert_equal  expected, parser.registrar
+    assert_equal  expected, parser.instance_eval { @registrar }
   end
 
 
-  def test_registrant
-    contact = @klass.new(load_part('/registered.txt')).registrant
+  def test_registrant_contact_with_available
+    contact = @klass.new(load_part('/registered.txt')).registrant_contact
     assert_instance_of Whois::Answer::Contact, contact
     assert_equal "mmr-32097", contact.id
     assert_equal "DNS Admin", contact.name
@@ -123,14 +125,15 @@ time. By submitting this query, you agree to abide by this policy.
     assert_equal "dns-admin@google.com", contact.email
   end
 
-  def test_registrant_with_available
-    assert_equal  nil,
-                  @klass.new(load_part('/available.txt')).registrant
+  def test_registrant_contact_with_available
+    parser      = @klass.new(load_part('/available.txt'))
+    expected    = nil
+    assert_equal  expected, parser.registrant_contact
+    assert_equal  expected, parser.instance_eval { @registrant_contact }
   end
 
-
-  def test_admin
-    contact = @klass.new(load_part('/registered.txt')).admin
+  def test_admin_contact_with_registered
+    contact = @klass.new(load_part('/registered.txt')).admin_contact
     assert_instance_of Whois::Answer::Contact, contact
     assert_equal "mmr-32097", contact.id
     assert_equal "DNS Admin", contact.name
@@ -146,14 +149,15 @@ time. By submitting this query, you agree to abide by this policy.
     assert_equal "dns-admin@google.com", contact.email
   end
 
-  def test_admin_with_available
-    assert_equal  nil,
-                  @klass.new(load_part('/available.txt')).admin
+  def test_admin_contact_with_available
+    parser      = @klass.new(load_part('/available.txt'))
+    expected    = nil
+    assert_equal  expected, parser.admin_contact
+    assert_equal  expected, parser.instance_eval { @admin_contact }
   end
 
-
-  def test_technical
-    contact = @klass.new(load_part('/registered.txt')).technical
+  def test_technical_contact_with_registered
+    contact = @klass.new(load_part('/registered.txt')).technical_contact
     assert_instance_of Whois::Answer::Contact, contact
     assert_equal "mmr-32097", contact.id
     assert_equal "DNS Admin", contact.name
@@ -169,9 +173,11 @@ time. By submitting this query, you agree to abide by this policy.
     assert_equal "dns-admin@google.com", contact.email
   end
 
-  def test_technical_with_available
-    assert_equal  nil,
-                  @klass.new(load_part('/available.txt')).technical
+  def test_technical_contact_with_available
+    parser      = @klass.new(load_part('/available.txt'))
+    expected    = nil
+    assert_equal  expected, parser.technical_contact
+    assert_equal  expected, parser.instance_eval { @technical_contact }
   end
 
 

data/test/answer/parser_test.rb

@@ -2,6 +2,20 @@ 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, [])
@@ -75,6 +89,35 @@ class AnswerParserTest < Test::Unit::TestCase
   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
@@ -89,6 +132,7 @@ class AnswerParserTest < Test::Unit::TestCase
       :expires_on_supported
     end
   end
+
   class Whois::Answer::Parser::TestParserUndefined < Whois::Answer::Parser::Base
     property_supported :status do
       :status_undefined
@@ -97,6 +141,7 @@ class AnswerParserTest < Test::Unit::TestCase
     # 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

data/test/answer_test.rb

@@ -77,6 +77,13 @@ class AnswerTest < Test::Unit::TestCase
   end
 
 
+  def test_contacts
+    answer = @klass.new(@server, @parts)
+    answer.parser.expects(:contacts).returns([])
+    assert_equal [], answer.contacts
+  end
+
+
   def test_parser
     answer = @klass.new(nil, [Whois::Answer::Part.new("", "whois.nic.it")])
     assert_instance_of Whois::Answer::Parser, answer.parser

data/test/list_tld

@@ -52,14 +52,14 @@ af;whois.nic.af;google.af;u34jedzcq.af
 af;whois.nic.ag;google.ag;u34jedzcq.ag
 ai;whois.ai;google.ai;u34jedzcq.ai
 al;;;
-#Whois::Server.define :tld, ".am", "whois.nic.am"
+am;whois.nic.am;google.am;u34jedzcq.am
 an;;;
 ao;;;
 aq;;;
 ar;;;
-#Whois::Server.define :tld, ".as", "whois.nic.as"
+as;whois.nic.as;google.as;u34jedzcq.as
 at;whois.nic.at;google.at;u34jedzcq.at
-#Whois::Server.define :tld, ".au", "whois.ausregistry.net.au"
+au;whois.ausregistry.net.au;google.com.au;u34jedzcq.com.au
 aw;;;
 ax;;;
 az;;;
@@ -255,7 +255,7 @@ sm;whois.ripe.net;google.sm;u34jedzcq.sm
 #Whois::Server.define :tld, ".sn", "whois.nic.sn"
 so;;;
 sr;;;
-#Whois::Server.define :tld, ".st", "whois.nic.st"
+st;whois.nic.st;google.st;u34jedzcq.st
 su;whois.ripn.net;google.su;u34jedzcq.su
 sv;;;
 sy;;;