Improved test harness and code quality.

lib/whois/server.rb

@@ -20,6 +20,7 @@
 require 'whois/server/adapters/arpa'
 require 'whois/server/adapters/formatted'
 require 'whois/server/adapters/none'
+require 'whois/server/adapters/pir'
 require 'whois/server/adapters/verisign'
 require 'whois/server/adapters/web'
 
@@ -29,17 +30,17 @@ module Whois
   class Server
 
     @@definitions = []
-
-    def self.define(extension, server, options = {})
-      @@definitions << [extension, server, options]
-    end
-
+
     def self.definitions
       @@definitions
     end
 
-    def self.factory(definition)
-      extension, server, options = definition
+    def self.define(extension, server, options = {})
+      @@definitions << [extension, server, options]
+    end
+
+    def self.factory(extension, server, options = {})
+      options = options.dup
       (options.delete(:adapter) || Adapters::Standard).new(extension, server, options)
     end
 
@@ -49,37 +50,39 @@ def self.guess(qstring)
       # TODO: IPv6 address
 
       # Email Address
-      if qstring =~ /@/
-        find_for_email(qstring)
+      if qstring =~ /@/ && server = find_for_email(qstring)
+        return server
       end
 
       # TODO: NSI NIC
       # TODO: ASN32
       # TODO: IP
 
-      # Domain
-      find_for_domain(qstring)
+      # TLD
+      if server = find_for_tld(qstring)
+        return server
+      end
 
       # TODO: guessing
       # TODO: game-over
-    end
-
-
-    def self.find_for_email(qstring)
-      raise ServerNotSupported, "No whois server is known for email objects"
-    end
-
-    def self.find_for_domain(qstring)
-      server = definitions.each do |definition|
-        return factory(definition) if /#{definition.first}$/ =~ qstring
-      end
+
       # you might want to remove this raise statement
       # to make the guessing more clever.
       raise ServerNotFound, "Unable to find a whois server for `#{qstring}'"
     end
 
+
     private
-
+
+      def self.find_for_email(qstring)
+        raise ServerNotSupported, "No whois server is known for email objects"
+      end
+
+      def self.find_for_tld(qstring)
+        server = definitions.each do |definition|
+          return factory(*definition) if /#{definition.first}$/ =~ qstring
+        end
+      end
 
   end
 

lib/whois/server/adapters/afilias.rb

@@ -21,9 +21,9 @@ module Adapters
       class Afilias < Base
 
         def query(qstring)
-          response = ask_the_socket(qstring, "whois.afilias-grs.info")
+          response = ask_the_socket(qstring, "whois.afilias-grs.info", DEFAULT_WHOIS_PORT)
           if response =~ /Domain Name:/ && response =~ /Whois Server:(\S+)/
-            ask_the_socket(qstring, $1)
+            ask_the_socket(qstring, $1, DEFAULT_WHOIS_PORT)
           else
             response
           end

lib/whois/server/adapters/arpa.rb

@@ -18,7 +18,7 @@ module Whois
   class Server
     module Adapters
 
-      class Pir < Base
+      class Arpa < Base
 
         def query(qstring)
           Server.guess(inaddr_to_ip(qstring)).query(qstring)

lib/whois/server/adapters/base.rb

@@ -19,6 +19,9 @@ class Server
     module Adapters
 
       class Base
+
+        DEFAULT_WHOIS_PORT = 43
+
 
         attr_reader :extension
         attr_reader :server
@@ -35,9 +38,15 @@ def query(qstring)
         end
 
 
+        protected
+
+          def query_the_socket(qstring, server, port = nil)
+            ask_the_socket(qstring, server, port || options[:port] || DEFAULT_WHOIS_PORT)
+          end
+
         private
-          
-          def ask_the_socket(qstring, server, port = 43)
+
+          def ask_the_socket(qstring, server, port)
             client = TCPSocket.open(server, port)
             client.write("#{qstring}\r\n")  # I could use put(foo) and forget the \n
             client.read                   # but write/read sounds better than puts/read

lib/whois/server/adapters/formatted.rb

@@ -21,7 +21,7 @@ module Adapters
       class Formatted < Base
 
         def query(qstring)
-          ask_the_socket(sprintf(options[:format], qstring), server, options[:port] || 43)
+          query_the_socket(sprintf(options[:format], qstring), server)
         end
 
       end

lib/whois/server/adapters/pir.rb

@@ -21,10 +21,10 @@ module Adapters
       class Pir < Base
 
         def query(qstring)
-          response = ask_the_socket("FULL #{qstring}", "whois.publicinterestregistry.net")
+          response = ask_the_socket("FULL #{qstring}", "whois.publicinterestregistry.net", DEFAULT_WHOIS_PORT)
           if response =~ /Registrant Name:SEE SPONSORING REGISTRAR/ && 
              response =~ /Registrant Street1:Whois Server:(\S+)/
-            ask_the_socket(qstring, $1)
+            ask_the_socket(qstring, $1, DEFAULT_WHOIS_PORT)
           else
             response
           end

lib/whois/server/adapters/standard.rb

@@ -21,7 +21,7 @@ module Adapters
       class Standard < Base
 
         def query(qstring)
-          ask_the_socket(qstring, server, options[:port] || 43)
+          query_the_socket(qstring, server)
         end
 
       end

lib/whois/server/adapters/verisign.rb

@@ -21,9 +21,9 @@ module Adapters
       class Verisign < Base
 
         def query(qstring)
-          response = ask_the_socket("=#{qstring}", "whois.crsnic.net")
+          response = ask_the_socket("=#{qstring}", "whois.crsnic.net", DEFAULT_WHOIS_PORT)
           if response =~ /Domain Name:/ && response =~ /Whois Server: (\S+)/
-            ask_the_socket(qstring, $1)
+            ask_the_socket(qstring, $1, DEFAULT_WHOIS_PORT)
           else
             response
           end

test/adapters/afilias_test.rb

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

test/adapters/none_test.rb

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

test/adapters/pir_test.rb

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

test/adapters/standard_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class ServerAdaptersStandardTest < Test::Unit::TestCase
+  include Whois
+
+  def setup
+    @definition = [".foo", "whois.foo", {}]
+    @klass = Server::Adapters::Standard
+    @server = @klass.new(*@definition)
+  end
+
+  def test_query
+    @server.expects(:ask_the_socket).with("domain.foo", "whois.foo", 43)
+    @server.query("domain.foo")
+  end
+
+  def test_query_with_port
+    @server = @klass.new(".foo", "whois.foo", { :port => 20 })
+    @server.expects(:ask_the_socket).with("domain.foo", "whois.foo", 20)
+    @server.query("domain.foo")
+  end
+
+end

test/adapters/verisign_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class ServerAdaptersVerisignTest < Test::Unit::TestCase
+  include Whois
+
+  def setup
+    @definition = [".foo", "whois.foo", {}]
+    @klass = Server::Adapters::Verisign
+    @server = @klass.new(*@definition)
+  end
+
+  def test_query
+    expected = "No match for DOMAIN.FOO."
+    @server.expects(:ask_the_socket).with("=domain.foo", "whois.crsnic.net", 43).returns(expected)
+    assert_equal expected, @server.query("domain.foo")
+  end
+
+  def test_query_with_referral
+    response = File.read(File.dirname(__FILE__) + "/../testcases/referrals/crsnic.com.txt")
+    expected = "Match for DOMAIN.FOO."
+    @server.expects(:ask_the_socket).with("=domain.foo", "whois.crsnic.net", 43).returns(response)
+    @server.expects(:ask_the_socket).with("domain.foo", "whois.tucows.com", 43).returns(expected)
+    assert_equal expected, @server.query("domain.foo")
+  end
+
+end

test/adapters/web_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class ServerAdaptersWebTest < Test::Unit::TestCase
+  include Whois
+
+  def setup
+    @definition = [".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

test/server_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class ServerTest < Test::Unit::TestCase
+  include Whois
+
+  def test_guess_should_recognize_email
+    Server.expects(:find_for_email).with("email@example.org").returns(true)
+    assert Server.guess("email@example.org")
+  end
+
+  def test_guess_should_recognize_tld
+    Server.expects(:find_for_tld).with("google.com").returns(true)
+    assert Server.guess("google.com")
+  end
+
+
+  def test_definitions
+    assert_instance_of Array, Server.definitions
+  end
+
+
+  def test_define
+    Server.define(".foo", "whois.foo")
+    assert_equal [".foo", "whois.foo", {}], Server.definitions.last
+  end
+
+  def test_define_with_options
+    Server.define(".foo", "whois.foo", :foo => "bar")
+    assert_equal [".foo", "whois.foo", { :foo => "bar" }], Server.definitions.last
+  end
+
+
+  def test_factory
+    server = Server.factory(".foo", "whois.foo")
+    assert_instance_of Server::Adapters::Standard, server
+  end
+
+  def test_factory_with_adapter
+    server = Server.factory(".foo", "whois.foo", :adapter => Server::Adapters::None)
+    assert_instance_of Server::Adapters::None, server
+  end
+
+  def test_factory_with_adapter_should_delete_adapter_option
+    server = Server.factory(".foo", "whois.foo", :adapter => Server::Adapters::None, :foo => "bar")
+    assert_equal server.options, { :foo => "bar" } 
+  end
+
+
+end