geocoder 1.1.5 → 1.1.6

data/test/result_test.rb

@@ -5,7 +5,7 @@ class ResultTest < Test::Unit::TestCase
 
   def test_result_has_required_attributes
     Geocoder::Lookup.all_services_except_test.each do |l|
-      Geocoder::Configuration.lookup = l
+      Geocoder.configure(:lookup => l)
       set_api_key!(l)
       result = Geocoder.search([45.423733, -75.676333]).first
       assert_result_has_required_attributes(result)
@@ -16,7 +16,7 @@ class ResultTest < Test::Unit::TestCase
   private # ------------------------------------------------------------------
 
   def assert_result_has_required_attributes(result)
-    m = "Lookup #{Geocoder::Configuration.lookup} does not support %s attribute."
+    m = "Lookup #{Geocoder.config.lookup} does not support %s attribute."
     assert result.coordinates.is_a?(Array),    m % "coordinates"
     assert result.latitude.is_a?(Float),       m % "latitude"
     assert result.longitude.is_a?(Float),      m % "longitude"

data/test/services_test.rb

@@ -3,20 +3,6 @@ require 'test_helper'
 
 class ServicesTest < Test::Unit::TestCase
 
-
-  def test_query_url_contains_values_in_params_hash
-    Geocoder::Lookup.all_services_except_test.each do |l|
-      next if l == :freegeoip # does not use query string
-      set_api_key!(l)
-      url = Geocoder::Lookup.get(l).send(:query_url, Geocoder::Query.new(
-        "test", :params => {:one_in_the_hand => "two in the bush"}
-      ))
-      # should be "+"s for all lookups except Yahoo
-      assert_match /one_in_the_hand=two(%20|\+)in(%20|\+)the(%20|\+)bush/, url,
-        "Lookup #{l} does not appear to support arbitrary params in URL"
-    end
-  end
-
   # --- Google ---
 
   def test_google_result_components
@@ -25,6 +11,12 @@ class ServicesTest < Test::Unit::TestCase
       result.address_components_of_type(:sublocality).first['long_name']
   end
 
+  def test_google_result_components_contains_route
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "Penn Plaza",
+      result.address_components_of_type(:route).first['long_name']
+  end
+
   def test_google_returns_city_when_no_locality_in_result
     result = Geocoder.search("no locality").first
     assert_equal "Haram", result.city
@@ -43,17 +35,46 @@ class ServicesTest < Test::Unit::TestCase
 
   def test_google_query_url_contains_bounds
     lookup = Geocoder::Lookup::Google.new
-    url = lookup.send(:query_url, Geocoder::Query.new(
+    url = lookup.query_url(Geocoder::Query.new(
       "Some Intersection",
       :bounds => [[40.0, -120.0], [39.0, -121.0]]
     ))
     assert_match /bounds=40.0+%2C-120.0+%7C39.0+%2C-121.0+/, url
   end
 
+  def test_google_query_url_contains_region
+    lookup = Geocoder::Lookup::Google.new
+    url = lookup.query_url(Geocoder::Query.new(
+      "Some Intersection",
+      :region => "gb"
+    ))
+    assert_match /region=gb/, url
+  end
+
+  def test_google_query_url_contains_components_when_given_as_string
+    lookup = Geocoder::Lookup::Google.new
+    url = lookup.query_url(Geocoder::Query.new(
+      "Some Intersection",
+      :components => "locality:ES"
+    ))
+    formatted = "components=" + CGI.escape("locality:ES")
+    assert url.include?(formatted), "Expected #{formatted} to be included in #{url}"
+  end
+
+  def test_google_query_url_contains_components_when_given_as_array
+    lookup = Geocoder::Lookup::Google.new
+    url = lookup.query_url(Geocoder::Query.new(
+      "Some Intersection",
+      :components => ["country:ES", "locality:ES"]
+    ))
+    formatted = "components=" + CGI.escape("country:ES|locality:ES")
+    assert url.include?(formatted), "Expected #{formatted} to be included in #{url}"
+  end
+
   # --- Google Premier ---
 
   def test_google_premier_result_components
-    Geocoder::Configuration.lookup = :google_premier
+    Geocoder.configure(:lookup => :google_premier)
     set_api_key!(:google_premier)
     result = Geocoder.search("Madison Square Garden, New York, NY").first
     assert_equal "Manhattan",
@@ -61,21 +82,23 @@ class ServicesTest < Test::Unit::TestCase
   end
 
   def test_google_premier_query_url
-    Geocoder::Configuration.api_key = ["deadbeef", "gme-test", "test-dev"]
+    Geocoder.configure(:api_key => ["deadbeef", "gme-test", "test-dev"])
     assert_equal "http://maps.googleapis.com/maps/api/geocode/json?address=Madison+Square+Garden%2C+New+York%2C+NY&channel=test-dev&client=gme-test&language=en&sensor=false&signature=doJvJqX7YJzgV9rJ0DnVkTGZqTg=",
-      Geocoder::Lookup::GooglePremier.new.send(:query_url, Geocoder::Query.new("Madison Square Garden, New York, NY"))
+      Geocoder::Lookup::GooglePremier.new.query_url(Geocoder::Query.new("Madison Square Garden, New York, NY"))
   end
 
 
   # --- Yahoo ---
 
   def test_yahoo_no_results
-    Geocoder::Configuration.lookup = :yahoo
+    Geocoder.configure(:lookup => :yahoo)
+    set_api_key!(:yahoo)
     assert_equal [], Geocoder.search("no results")
   end
 
   def test_yahoo_error
-    Geocoder::Configuration.lookup = :yahoo
+    Geocoder.configure(:lookup => :yahoo)
+    set_api_key!(:yahoo)
     # keep test output clean: suppress timeout warning
     orig = $VERBOSE; $VERBOSE = nil
     assert_equal [], Geocoder.search("error")
@@ -84,34 +107,32 @@ class ServicesTest < Test::Unit::TestCase
   end
 
   def test_yahoo_result_components
-    Geocoder::Configuration.lookup = :yahoo
+    Geocoder.configure(:lookup => :yahoo)
+    set_api_key!(:yahoo)
     result = Geocoder.search("madison square garden").first
     assert_equal "10001", result.postal_code
   end
 
   def test_yahoo_address_formatting
-    Geocoder::Configuration.lookup = :yahoo
+    Geocoder.configure(:lookup => :yahoo)
+    set_api_key!(:yahoo)
     result = Geocoder.search("madison square garden").first
     assert_equal "Madison Square Garden, New York, NY 10001, United States", result.address
   end
 
-
-  # --- Yandex ---
-
-  def test_yandex_with_invalid_key
-    # keep test output clean: suppress timeout warning
-    orig = $VERBOSE; $VERBOSE = nil
-    Geocoder::Configuration.lookup = :yandex
-    assert_equal [], Geocoder.search("invalid key")
-  ensure
-    $VERBOSE = orig
+  def test_yahoo_raises_exception_when_over_query_limit
+    Geocoder.configure(:always_raise => [Geocoder::OverQueryLimitError])
+    l = Geocoder::Lookup.get(:yahoo)
+    assert_raises Geocoder::OverQueryLimitError do
+      l.send(:results, Geocoder::Query.new("over limit"))
+    end
   end
 
-
   # --- Geocoder.ca ---
 
   def test_geocoder_ca_result_components
-    Geocoder::Configuration.lookup = :geocoder_ca
+    Geocoder.configure(:lookup => :geocoder_ca)
+    set_api_key!(:geocoder_ca)
     result = Geocoder.search([45.423733, -75.676333]).first
     assert_equal "CA", result.country_code
     assert_equal "289 Somerset ST E, Ottawa, ON K1N6W1, Canada", result.address
@@ -130,11 +151,56 @@ class ServicesTest < Test::Unit::TestCase
     assert_equal "Plano, TX 75093, United States", result.address
   end
 
+  # --- MaxMind ---
+
+  def test_maxmind_result_on_ip_address_search
+    Geocoder.configure(:ip_lookup => :maxmind, :maxmind => {:service => :city_isp_org})
+    result = Geocoder.search("74.200.247.59").first
+    assert result.is_a?(Geocoder::Result::Maxmind)
+  end
+
+  def test_maxmind_result_knows_country_service_name
+    Geocoder.configure(:ip_lookup => :maxmind)
+    assert_equal :country, Geocoder.search("24.24.24.21").first.service_name
+  end
+
+  def test_maxmind_result_knows_city_service_name
+    Geocoder.configure(:ip_lookup => :maxmind)
+    assert_equal :city, Geocoder.search("24.24.24.22").first.service_name
+  end
+
+  def test_maxmind_result_knows_city_isp_org_service_name
+    Geocoder.configure(:ip_lookup => :maxmind)
+    assert_equal :city_isp_org, Geocoder.search("24.24.24.23").first.service_name
+  end
+
+  def test_maxmind_result_knows_omni_service_name
+    Geocoder.configure(:ip_lookup => :maxmind)
+    assert_equal :omni, Geocoder.search("24.24.24.24").first.service_name
+  end
+
+  def test_maxmind_special_result_components
+    Geocoder.configure(:ip_lookup => :maxmind)
+    result = Geocoder.search("24.24.24.24").first
+    assert_equal "Road Runner", result.isp_name
+    assert_equal "Cable/DSL", result.netspeed
+    assert_equal "rr.com", result.domain
+  end
+
+  def test_maxmind_raises_exception_when_service_not_configured
+    Geocoder.configure(:ip_lookup => :maxmind)
+    Geocoder.configure(:maxmind => {:service => nil})
+    assert_raises Geocoder::ConfigurationError do
+      Geocoder::Query.new("24.24.24.24").url
+    end
+  end
+
 
   # --- Bing ---
 
   def test_bing_result_components
-    Geocoder::Configuration.lookup = :bing
+    Geocoder.configure(:lookup => :bing)
+    set_api_key!(:bing)
     result = Geocoder.search("Madison Square Garden, New York, NY").first
     assert_equal "Madison Square Garden, NY", result.address
     assert_equal "NY", result.state
@@ -142,7 +208,8 @@ class ServicesTest < Test::Unit::TestCase
   end
 
   def test_bing_no_results
-    Geocoder::Configuration.lookup = :bing
+    Geocoder.configure(:lookup => :bing)
+    set_api_key!(:bing)
     results = Geocoder.search("no results")
     assert_equal 0, results.length
   end
@@ -150,38 +217,48 @@ class ServicesTest < Test::Unit::TestCase
   # --- Nominatim ---
 
   def test_nominatim_result_components
-    Geocoder::Configuration.lookup = :nominatim
+    Geocoder.configure(:lookup => :nominatim)
+    set_api_key!(:nominatim)
     result = Geocoder.search("Madison Square Garden, New York, NY").first
     assert_equal "10001", result.postal_code
   end
 
   def test_nominatim_address_formatting
-    Geocoder::Configuration.lookup = :nominatim
+    Geocoder.configure(:lookup => :nominatim)
+    set_api_key!(:nominatim)
     result = Geocoder.search("Madison Square Garden, New York, NY").first
     assert_equal "Madison Square Garden, West 31st Street, Long Island City, New York City, New York, 10001, United States of America",
       result.address
   end
+
+  def test_nominatim_host_config
+    Geocoder.configure(:lookup => :nominatim, :nominatim => {:host => "local.com"})
+    lookup = Geocoder::Lookup::Nominatim.new
+    query = Geocoder::Query.new("Bluffton, SC")
+    assert_match %r(http://local\.com), lookup.query_url(query)
+  end
+
   # --- MapQuest ---
 
   def test_api_route
-    Geocoder::Configuration.lookup = :mapquest
-    Geocoder::Configuration.api_key = "abc123"
-
+    Geocoder.configure(:lookup => :mapquest, :api_key => "abc123")
     lookup = Geocoder::Lookup::Mapquest.new
     query = Geocoder::Query.new("Bluffton, SC")
-    res = lookup.send(:query_url, query)
+    res = lookup.query_url(query)
     assert_equal "http://www.mapquestapi.com/geocoding/v1/address?key=abc123&location=Bluffton%2C+SC",
       res
   end
 
   def test_mapquest_result_components
-    Geocoder::Configuration.lookup = :mapquest
+    Geocoder.configure(:lookup => :mapquest)
+    set_api_key!(:mapquest)
     result = Geocoder.search("Madison Square Garden, New York, NY").first
     assert_equal "10001", result.postal_code
   end
 
   def test_mapquest_address_formatting
-    Geocoder::Configuration.lookup = :mapquest
+    Geocoder.configure(:lookup => :mapquest)
+    set_api_key!(:mapquest)
     result = Geocoder.search("Madison Square Garden, New York, NY").first
     assert_equal "46 West 31st Street, New York, NY, 10001, US",
       result.address

data/test/test_helper.rb

@@ -73,7 +73,11 @@ require "geocoder/lookups/base"
 module Geocoder
   module Lookup
     class Base
-      private #-----------------------------------------------------------------
+      private
+      def fixture_exists?(filename)
+        File.exist?(File.join("test", "fixtures", filename))
+      end
+
       def read_fixture(file)
         filepath = File.join("test", "fixtures", file)
         s = File.read(filepath).strip.gsub(/\n\s*/, "")
@@ -83,124 +87,56 @@ module Geocoder
         end
         s
       end
-    end
 
-    class Google < Base
-      private #-----------------------------------------------------------------
-      def make_api_request(query)
-        raise TimeoutError if query.text == "timeout"
-        raise SocketError if query.text == "socket_error"
-        file = case query.text
-          when "no results";   :no_results
-          when "no locality";  :no_locality
-          when "no city data"; :no_city_data
-          else                 :madison_square_garden
-        end
-        read_fixture "google_#{file}.json"
+      ##
+      # Fixture to use if none match the given query.
+      #
+      def default_fixture_filename
+        "#{fixture_prefix}_madison_square_garden"
       end
-    end
-
-    class GooglePremier < Google
-    end
 
-    class Yahoo < Base
-      private #-----------------------------------------------------------------
-      def make_api_request(query)
-        raise TimeoutError if query.text == "timeout"
-        raise SocketError if query.text == "socket_error"
-        file = case query.text
-          when "no results"; :no_results
-          when "error";      :error
-          else               :madison_square_garden
-        end
-        read_fixture "yahoo_#{file}.json"
+      def fixture_prefix
+        handle
       end
-    end
 
-    class Yandex < Base
-      private #-----------------------------------------------------------------
-      def make_api_request(query)
-        raise TimeoutError if query.text == "timeout"
-        raise SocketError if query.text == "socket_error"
-        file = case query.text
-          when "no results";  :no_results
-          when "invalid key"; :invalid_key
-          else                :kremlin
-        end
-        read_fixture "yandex_#{file}.json"
+      def fixture_for_query(query)
+        label = query.reverse_geocode? ? "reverse" : query.text.gsub(/[ \.]/, "_")
+        filename = "#{fixture_prefix}_#{label}"
+        fixture_exists?(filename) ? filename : default_fixture_filename
       end
-    end
 
-    class GeocoderCa < Base
-      private #-----------------------------------------------------------------
       def make_api_request(query)
         raise TimeoutError if query.text == "timeout"
         raise SocketError if query.text == "socket_error"
-        if query.reverse_geocode?
-          read_fixture "geocoder_ca_reverse.json"
-        else
-          file = case query.text
-            when "no results";  :no_results
-            else                :madison_square_garden
-          end
-          read_fixture "geocoder_ca_#{file}.json"
-        end
+        read_fixture fixture_for_query(query)
       end
     end
 
-    class Freegeoip < Base
-      private #-----------------------------------------------------------------
-      def make_api_request(query)
-        raise TimeoutError if query.text == "timeout"
-        raise SocketError if query.text == "socket_error"
-        file = case query.text
-          when "no results";  :no_results
-          else                "74_200_247_59"
-        end
-        read_fixture "freegeoip_#{file}.json"
+    class GooglePremier
+      private
+      def fixture_prefix
+        "google"
       end
     end
 
-    class Bing < Base
-      private #-----------------------------------------------------------------
-      def make_api_request(query)
-        raise TimeoutError if query.text == "timeout"
-        raise SocketError if query.text == "socket_error"
-        if query.reverse_geocode?
-          read_fixture "bing_reverse.json"
-        else
-          file = case query.text
-            when "no results";  :no_results
-            else                :madison_square_garden
-          end
-          read_fixture "bing_#{file}.json"
-        end
+    class Yandex
+      private
+      def default_fixture_filename
+        "yandex_kremlin"
       end
     end
 
-    class Nominatim < Base
-      private #-----------------------------------------------------------------
-      def make_api_request(query)
-        raise TimeoutError if query.text == "timeout"
-        raise SocketError if query.text == "socket_error"
-        file = case query.text
-          when "no results";  :no_results
-          else                :madison_square_garden
-        end
-        read_fixture "nominatim_#{file}.json"
+    class Freegeoip
+      private
+      def default_fixture_filename
+        "freegeoip_74_200_247_59"
       end
     end
 
-    class Mapquest < Base
-      private #-----------------------------------------------------------------
-      def make_api_request(query)
-        raise TimeoutError if query.text == "timeout"
-        raise SocketError if query.text == "socket_error"
-        file = case query.text
-          when "no results";  :no_results
-          else                :madison_square_garden
-        end
-        read_fixture "mapquest_#{file}.json"
+    class Maxmind
+      private
+      def default_fixture_filename
+        "maxmind_74_200_247_59"
       end
     end
 
@@ -302,6 +238,10 @@ end
 
 class Test::Unit::TestCase
 
+  def setup
+    Geocoder.configure(:maxmind => {:service => :omni})
+  end
+
   def teardown
     Geocoder.send(:remove_const, :Configuration)
     load "geocoder/configuration.rb"
@@ -326,19 +266,14 @@ class Test::Unit::TestCase
   end
 
   def set_api_key!(lookup_name)
-    if lookup_name == :google_premier
-      Geocoder::Configuration.api_key = [
-        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-        'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
-        'cccccccccccccccccccccccccccccc'
-      ]
-    elsif lookup_name == :yahoo
-      Geocoder::Configuration.api_key = [
-        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-        'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
-      ]
+    lookup = Geocoder::Lookup.get(lookup_name)
+    if lookup.required_api_key_parts.size == 1
+      key = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+    elsif lookup.required_api_key_parts.size > 1
+      key = lookup.required_api_key_parts
     else
-      Geocoder::Configuration.api_key = nil
+      key = nil
     end
+    Geocoder.configure(:api_key => key)
   end
 end