geocoder 1.1.9 → 1.2.0

data/test/{geocoder_test.rb → unit/geocoder_test.rb}

@@ -1,12 +1,13 @@
 # encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
 require 'test_helper'
 
-class GeocoderTest < Test::Unit::TestCase
+class GeocoderTest < GeocoderTestCase
 
   def test_distance_to_returns_float
-    v = Venue.new(*venue_params(:msg))
+    v = Place.new(*geocoded_object_params(:msg))
     v.latitude, v.longitude = [40.750354, -73.993371]
-    assert (d = v.distance_to([30, -94])).is_a?(Float)
+    assert (v.distance_to([30, -94])).is_a?(Float)
   end
 
   def test_coordinates_method_returns_array
@@ -26,27 +27,27 @@ class GeocoderTest < Test::Unit::TestCase
   end
 
   def test_geocode_assigns_and_returns_coordinates
-    v = Venue.new(*venue_params(:msg))
+    v = Place.new(*geocoded_object_params(:msg))
     coords = [40.750354, -73.993371]
     assert_equal coords, v.geocode
     assert_equal coords, [v.latitude, v.longitude]
   end
 
   def test_geocode_block_executed_when_no_results
-    v = Event.new("Nowhere", "no results")
+    v = PlaceWithCustomResultsHandling.new("Nowhere", "no results")
     v.geocode
     assert_equal "NOT FOUND", v.coords_string
   end
 
   def test_reverse_geocode_assigns_and_returns_address
-    v = Landmark.new(*landmark_params(:msg))
+    v = PlaceReverseGeocoded.new(*reverse_geocoded_object_params(:msg))
     address = "4 Penn Plaza, New York, NY 10001, USA"
     assert_equal address, v.reverse_geocode
     assert_equal address, v.address
   end
 
   def test_forward_and_reverse_geocoding_on_same_model_works
-    g = GasStation.new("Exxon")
+    g = PlaceWithForwardAndReverseGeocoding.new("Exxon")
     g.address = "404 New St, Middletown, CT"
     g.geocode
     assert_not_nil g.lat
@@ -56,4 +57,22 @@ class GeocoderTest < Test::Unit::TestCase
     g.reverse_geocode
     assert_not_nil g.location
   end
+
+  def test_geocode_with_custom_lookup_param
+    v = PlaceWithCustomLookup.new(*geocoded_object_params(:msg))
+    v.geocode
+    assert_equal Geocoder::Result::Nominatim, v.result_class
+  end
+
+  def test_geocode_with_custom_lookup_proc_param
+    v = PlaceWithCustomLookupProc.new(*geocoded_object_params(:msg))
+    v.geocode
+    assert_equal Geocoder::Result::Nominatim, v.result_class
+  end
+
+  def test_reverse_geocode_with_custom_lookup_param
+    v = PlaceReverseGeocodedWithCustomLookup.new(*reverse_geocoded_object_params(:msg))
+    v.reverse_geocode
+    assert_equal Geocoder::Result::Nominatim, v.result_class
+  end
 end

data/test/{https_test.rb → unit/https_test.rb}

@@ -1,16 +1,17 @@
 # encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
 require 'test_helper'
 
-class HttpsTest < Test::Unit::TestCase
+class HttpsTest < GeocoderTestCase
 
   def test_uses_https_for_secure_query
     Geocoder.configure(:use_https => true)
     g = Geocoder::Lookup::Google.new
-    assert_match /^https:/, g.query_url(Geocoder::Query.new("test"))
+    assert_match(/^https:/, g.query_url(Geocoder::Query.new("test")))
   end
 
   def test_uses_http_by_default
     g = Geocoder::Lookup::Google.new
-    assert_match /^http:/, g.query_url(Geocoder::Query.new("test"))
+    assert_match(/^http:/, g.query_url(Geocoder::Query.new("test")))
   end
 end

data/test/unit/ip_address_test.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class IpAddressTest < GeocoderTestCase
+
+  def test_valid
+    assert Geocoder::IpAddress.new("232.65.123.94").valid?
+    assert Geocoder::IpAddress.new("666.65.123.94").valid? # technically invalid
+    assert Geocoder::IpAddress.new("::ffff:12.34.56.78").valid?
+    assert !Geocoder::IpAddress.new("232.65.123.94.43").valid?
+    assert !Geocoder::IpAddress.new("232.65.123").valid?
+    assert !Geocoder::IpAddress.new("::ffff:123.456.789").valid?
+    assert !Geocoder::IpAddress.new("Test\n232.65.123.94").valid?
+  end
+
+  def test_loopback
+    assert Geocoder::IpAddress.new("0.0.0.0").loopback?
+    assert Geocoder::IpAddress.new("127.0.0.1").loopback?
+    assert !Geocoder::IpAddress.new("232.65.123.234").loopback?
+    assert !Geocoder::IpAddress.new("127 Main St.").loopback?
+    assert !Geocoder::IpAddress.new("John Doe\n127 Main St.\nAnywhere, USA").loopback?
+  end
+end

data/test/{lookup_test.rb → unit/lookup_test.rb}

@@ -1,7 +1,8 @@
 # encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
 require 'test_helper'
 
-class LookupTest < Test::Unit::TestCase
+class LookupTest < GeocoderTestCase
 
   def test_responds_to_name_method
     Geocoder::Lookup.all_services.each do |l|
@@ -22,14 +23,14 @@ class LookupTest < 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
+      next if l == :freegeoip || l == :maxmind_local # does not use query string
       set_api_key!(l)
       url = Geocoder::Lookup.get(l).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"
+      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
 
@@ -50,15 +51,15 @@ class LookupTest < Test::Unit::TestCase
       url = Geocoder::Lookup.get(l).query_url(Geocoder::Query.new(
         "test", :params => {p => "xxxx"}
       ))
-      assert_match /#{p}=xxxx/, url,
-        "Param passed to #{l} lookup does not override configuration value"
+      assert_match(/#{p}=xxxx/, url,
+        "Param passed to #{l} lookup does not override configuration value")
     end
   end
 
   def test_raises_exception_on_invalid_key
     Geocoder.configure(:always_raise => [Geocoder::InvalidApiKey])
     #Geocoder::Lookup.all_services_except_test.each do |l|
-    [:bing, :yahoo, :yandex, :maxmind].each do |l|
+    [:bing, :yahoo, :yandex, :maxmind, :baidu, :baidu_ip].each do |l|
       lookup = Geocoder::Lookup.get(l)
       assert_raises Geocoder::InvalidApiKey do
         lookup.send(:results, Geocoder::Query.new("invalid key"))
@@ -67,22 +68,20 @@ class LookupTest < Test::Unit::TestCase
   end
 
   def test_returns_empty_array_on_invalid_key
-    # keep test output clean: suppress timeout warning
-    orig = $VERBOSE; $VERBOSE = nil
-    #Geocoder::Lookup.all_services_except_test.each do |l|
-    [:bing, :yahoo, :yandex, :maxmind].each do |l|
-      Geocoder.configure(:lookup => l)
-      set_api_key!(l)
-      assert_equal [], Geocoder.search("invalid key")
+    silence_warnings do
+      #Geocoder::Lookup.all_services_except_test.each do |l|
+      [:bing, :yahoo, :yandex, :maxmind, :cloudmade, :baidu, :baidu_ip].each do |l|
+        Geocoder.configure(:lookup => l)
+        set_api_key!(l)
+        assert_equal [], Geocoder.search("invalid key")
+      end
     end
-  ensure
-    $VERBOSE = orig
   end
 
   def test_does_not_choke_on_nil_address
     Geocoder::Lookup.all_services.each do |l|
       Geocoder.configure(:lookup => l)
-      assert_nothing_raised { Venue.new("Venue", nil).geocode }
+      assert_nothing_raised { Place.new("Place", nil).geocode }
     end
   end
 
@@ -91,6 +90,18 @@ class LookupTest < Test::Unit::TestCase
     assert_equal "a=1&b=2", g.send(:hash_to_query, {:a => 1, :b => 2})
   end
 
+  def test_baidu_api_key
+    Geocoder.configure(:api_key => "MY_KEY")
+    g = Geocoder::Lookup::BaiduIp.new
+    assert_match "ak=MY_KEY", g.query_url(Geocoder::Query.new("232.65.123.94"))
+  end
+
+  def test_baidu_ip_api_key
+    Geocoder.configure(:api_key => "MY_KEY")
+    g = Geocoder::Lookup::Baidu.new
+    assert_match "ak=MY_KEY", g.query_url(Geocoder::Query.new("Madison Square Garden, New York, NY  10001, United States"))
+  end
+
   def test_google_api_key
     Geocoder.configure(:api_key => "MY_KEY")
     g = Geocoder::Lookup::Google.new
@@ -104,9 +115,11 @@ class LookupTest < Test::Unit::TestCase
   end
 
   def test_raises_configuration_error_on_missing_key
-    assert_raises Geocoder::ConfigurationError do
-      Geocoder.configure(:lookup => :bing, :api_key => nil)
-      Geocoder.search("Madison Square Garden, New York, NY  10001, United States")
+    [:bing, :baidu].each do |l|
+      assert_raises Geocoder::ConfigurationError do
+        Geocoder.configure(:lookup => l, :api_key => nil)
+        Geocoder.search("Madison Square Garden, New York, NY  10001, United States")
+      end
     end
   end
 

data/test/unit/lookups/bing_test.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class BingTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(lookup: :bing)
+    set_api_key!(:bing)
+  end
+
+  def test_query_for_reverse_geocode
+    lookup = Geocoder::Lookup::Bing.new
+    url = lookup.query_url(Geocoder::Query.new([45.423733, -75.676333]))
+    assert_match(/Locations\/45.423733/, url)
+  end
+
+  def test_result_components
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "Madison Square Garden, NY", result.address
+    assert_equal "NY", result.state
+    assert_equal "New York", result.city
+  end
+
+  def test_no_results
+    results = Geocoder.search("no results")
+    assert_equal 0, results.length
+  end
+
+  def test_query_url_contains_region
+    lookup = Geocoder::Lookup::Bing.new
+    url = lookup.query_url(Geocoder::Query.new(
+      "manchester",
+      :region => "uk"
+    ))
+    assert_match(/Locations\/uk\/manchester/, url)
+    assert_no_match(/query/, url)
+  end
+
+  def test_query_url_without_region
+    lookup = Geocoder::Lookup::Bing.new
+    url = lookup.query_url(Geocoder::Query.new(
+      "manchester"
+    ))
+    assert_match(/Locations\/manchester/, url)
+    assert_no_match(/query/, url)
+  end
+
+  def test_query_url_contains_address_with_spaces
+    lookup = Geocoder::Lookup::Bing.new
+    url = lookup.query_url(Geocoder::Query.new(
+      "manchester, lancashire",
+      :region => "uk"
+    ))
+    assert_match(/Locations\/uk\/manchester,%20lancashire/, url)
+    assert_no_match(/query/, url)
+  end
+
+  def test_query_url_contains_address_with_trailing_and_leading_spaces
+    lookup = Geocoder::Lookup::Bing.new
+    url = lookup.query_url(Geocoder::Query.new(
+      " manchester, lancashire ",
+      :region => "uk"
+    ))
+    assert_match(/Locations\/uk\/manchester,%20lancashire/, url)
+    assert_no_match(/query/, url)
+  end
+end

data/test/unit/lookups/dstk_test.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class DstkTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(lookup: :dstk)
+  end
+
+  def test_dstk_result_components
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "Manhattan", result.address_components_of_type(:sublocality).first['long_name']
+  end
+
+  def test_dstk_query_url
+    query = Geocoder::Query.new("Madison Square Garden, New York, NY")
+    assert_equal "http://www.datasciencetoolkit.org/maps/api/geocode/json?address=Madison+Square+Garden%2C+New+York%2C+NY&language=en&sensor=false", query.url
+  end
+
+  def test_dstk_query_url_with_custom_host
+    Geocoder.configure(dstk: {host: 'NOT_AN_ACTUAL_HOST'})
+    query = Geocoder::Query.new("Madison Square Garden, New York, NY")
+    assert_equal "http://NOT_AN_ACTUAL_HOST/maps/api/geocode/json?address=Madison+Square+Garden%2C+New+York%2C+NY&language=en&sensor=false", query.url
+  end
+end

data/test/unit/lookups/esri_test.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class EsriTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(lookup: :esri)
+  end
+
+  def test_query_for_geocode
+    query = Geocoder::Query.new("Bluffton, SC")
+    lookup = Geocoder::Lookup.get(:esri)
+    res = lookup.query_url(query)
+    assert_equal "http://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/find?f=pjson&outFields=%2A&text=Bluffton%2C+SC",
+      res
+  end
+
+  def test_query_for_reverse_geocode
+    query = Geocoder::Query.new([45.423733, -75.676333])
+    lookup = Geocoder::Lookup.get(:esri)
+    res = lookup.query_url(query)
+    assert_equal "http://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/reverseGeocode?f=pjson&location=-75.676333%2C45.423733&outFields=%2A",
+      res
+  end
+
+  def test_results_component
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "10001", result.postal_code
+    assert_equal "USA", result.country
+    assert_equal "Madison Square Garden", result.address
+    assert_equal "New York", result.city
+    assert_equal "New York", result.state
+    assert_equal(40.75004981300049, result.coordinates[0])
+    assert_equal(-73.99423889799965, result.coordinates[1])
+  end
+
+  def test_results_component_when_reverse_geocoding
+    result = Geocoder.search([45.423733, -75.676333]).first
+    assert_equal "75007", result.postal_code
+    assert_equal "FRA", result.country
+    assert_equal "4 Avenue Gustave Eiffel", result.address
+    assert_equal "Paris", result.city
+    assert_equal "Île-de-France", result.state
+    assert_equal(48.858129997357558, result.coordinates[0])
+    assert_equal(2.2956200048981574, result.coordinates[1])
+  end
+end

data/test/unit/lookups/freegeoip_test.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class FreegeoipTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(ip_lookup: :freegeoip)
+  end
+
+  def test_result_on_ip_address_search
+    result = Geocoder.search("74.200.247.59").first
+    assert result.is_a?(Geocoder::Result::Freegeoip)
+  end
+
+  def test_result_components
+    result = Geocoder.search("74.200.247.59").first
+    assert_equal "Plano, TX 75093, United States", result.address
+  end
+
+  def test_host_config
+    Geocoder.configure(freegeoip: {host: "local.com"})
+    lookup = Geocoder::Lookup::Freegeoip.new
+    query = Geocoder::Query.new("24.24.24.23")
+    assert_match %r(http://local\.com), lookup.query_url(query)
+  end
+end

data/test/unit/lookups/geocoder_ca_test.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class GeocoderCaTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(lookup: :geocoder_ca)
+    set_api_key!(:geocoder_ca)
+  end
+
+  def test_result_components
+    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
+  end
+end

data/test/unit/lookups/geocodio_test.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class GeocodioTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(lookup: :geocodio)
+    set_api_key!(:geocodio)
+  end
+
+  def test_result_components
+    result = Geocoder.search("1101 Pennsylvania Ave NW, Washington DC").first
+    assert_equal 1.0, result.accuracy
+    assert_equal "1101", result.number
+    assert_equal "Ave", result.suffix
+    assert_equal "DC", result.state
+    assert_equal "20004", result.zip
+    assert_equal "NW", result.postdirectional
+    assert_equal "Washington", result.city
+    assert_equal "1101 Pennsylvania Ave NW, Washington DC, 20004", result.formatted_address
+    assert_equal({ "lat" => 38.895019, "lng" => -77.028095 }, result.location)
+  end
+
+  def test_no_results
+    results = Geocoder.search("no results")
+    assert_equal 0, results.length
+  end
+
+  def test_geocodio_reverse_url
+    query = Geocoder::Query.new([45.423733, -75.676333])
+    assert_match /reverse/, query.url
+  end
+
+  def test_raises_invalid_request_exception
+    Geocoder.configure Geocoder.configure(:always_raise => [Geocoder::InvalidRequest])
+    assert_raises Geocoder::InvalidRequest do
+      Geocoder.search("invalid")
+    end
+  end
+
+  def test_raises_api_key_exception
+    Geocoder.configure Geocoder.configure(:always_raise => [Geocoder::InvalidApiKey])
+    assert_raises Geocoder::InvalidApiKey do
+      Geocoder.search("bad api key")
+    end
+  end
+
+  def test_raises_over_limit_exception
+    Geocoder.configure Geocoder.configure(:always_raise => [Geocoder::OverQueryLimitError])
+    assert_raises Geocoder::OverQueryLimitError do
+      Geocoder.search("over query limit")
+    end
+  end
+end