geocoder 1.1.9 → 1.2.0

data/test/unit/lookups/google_premier_test.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class GooglePremierTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(lookup: :google_premier)
+    set_api_key!(:google_premier)
+  end
+
+  def test_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_query_url
+    Geocoder.configure(google_premier: {api_key: ["deadbeef", "gme-test", "test-dev"]})
+    query = Geocoder::Query.new("Madison Square Garden, New York, NY")
+    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=", query.url
+  end
+end

data/test/unit/lookups/google_test.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class GoogleTest < GeocoderTestCase
+
+  def test_google_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_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_result_components_contains_street_number
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "4",
+      result.address_components_of_type(:street_number).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
+  end
+
+  def test_google_city_results_returns_nil_if_no_matching_component_types
+    result = Geocoder.search("no city data").first
+    assert_equal nil, result.city
+  end
+
+  def test_google_street_address_returns_formatted_street_address
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "4 Penn Plaza", result.street_address
+  end
+
+  def test_google_precision
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "ROOFTOP",
+      result.precision
+  end
+
+  def test_google_query_url_contains_bounds
+    lookup = Geocoder::Lookup::Google.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
+
+end

data/test/unit/lookups/mapquest_test.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class MapquestTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(lookup: :mapquest)
+    set_api_key!(:mapquest)
+  end
+
+  def test_url_contains_api_key
+    Geocoder.configure(mapquest: {api_key: "abc123"})
+    query = Geocoder::Query.new("Bluffton, SC")
+    assert_equal "http://www.mapquestapi.com/geocoding/v1/address?key=abc123&location=Bluffton%2C+SC", query.url
+  end
+
+  def test_url_for_version_2
+    Geocoder.configure(mapquest: {api_key: "abc123", version: 2})
+    query = Geocoder::Query.new("Bluffton, SC")
+    assert_equal "http://www.mapquestapi.com/geocoding/v2/address?key=abc123&location=Bluffton%2C+SC", query.url
+  end
+
+  def test_url_for_open_street_maps
+    Geocoder.configure(mapquest: {api_key: "abc123", open: true})
+    query = Geocoder::Query.new("Bluffton, SC")
+    assert_equal "http://open.mapquestapi.com/geocoding/v1/address?key=abc123&location=Bluffton%2C+SC", query.url
+  end
+
+  def test_result_components
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "10001", result.postal_code
+    assert_equal "46 West 31st Street, New York, NY, 10001, US", result.address
+  end
+
+  def test_no_results
+    assert_equal [], Geocoder.search("no results")
+  end
+
+  def test_raises_exception_when_invalid_request
+    Geocoder.configure(always_raise: [Geocoder::InvalidRequest])
+    assert_raises Geocoder::InvalidRequest do
+      Geocoder.search("invalid request")
+    end
+  end
+
+  def test_raises_exception_when_invalid_api_key
+    Geocoder.configure(always_raise: [Geocoder::InvalidApiKey])
+    assert_raises Geocoder::InvalidApiKey do
+      Geocoder.search("invalid api key")
+    end
+  end
+
+  def test_raises_exception_when_error
+    Geocoder.configure(always_raise: [Geocoder::Error])
+    assert_raises Geocoder::Error do
+      Geocoder.search("error")
+    end
+  end
+end

data/test/unit/lookups/maxmind_local_test.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class MaxmindLocalTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(ip_lookup: :maxmind_local)
+  end
+
+  def test_result_attributes
+    result = Geocoder.search('8.8.8.8').first
+    assert_equal 'Mountain View, CA 94043, United States', result.address
+    assert_equal 'Mountain View', result.city
+    assert_equal 'CA', result.state
+    assert_equal 'United States', result.country
+    assert_equal 'US', result.country_code
+    assert_equal '94043', result.postal_code
+    assert_equal 37.41919999999999, result.latitude
+    assert_equal -122.0574, result.longitude
+    assert_equal [37.41919999999999, -122.0574], result.coordinates
+  end
+
+  def test_loopback
+    results = Geocoder.search('127.0.0.1')
+    assert_equal [], results
+  end
+end

data/test/unit/lookups/maxmind_test.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class MaxmindTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(ip_lookup: :maxmind)
+  end
+
+  def test_maxmind_result_on_ip_address_search
+    Geocoder.configure(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(maxmind: {service: :country})
+    assert_equal :country, Geocoder.search("24.24.24.21").first.service_name
+  end
+
+  def test_maxmind_result_knows_city_service_name
+    Geocoder.configure(maxmind: {service: :city})
+    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(maxmind: {service: :city_isp_org})
+    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(maxmind: {service: :omni})
+    assert_equal :omni, Geocoder.search("24.24.24.24").first.service_name
+  end
+
+  def test_maxmind_special_result_components
+    Geocoder.configure(maxmind: {service: :omni})
+    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(maxmind: {service: nil})
+    assert_raises Geocoder::ConfigurationError do
+      Geocoder::Query.new("24.24.24.24").url
+    end
+  end
+
+  def test_maxmind_works_when_loopback_address_on_omni
+    Geocoder.configure(maxmind: {service: :omni})
+    result = Geocoder.search("127.0.0.1").first
+    assert_equal "", result.country_code
+  end
+
+  def test_maxmind_works_when_loopback_address_on_country
+    Geocoder.configure(maxmind: {service: :country})
+    result = Geocoder.search("127.0.0.1").first
+    assert_equal "", result.country_code
+  end
+end

data/test/unit/lookups/nominatim_test.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class NominatimTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(lookup: :nominatim)
+    set_api_key!(:nominatim)
+  end
+
+  def test_result_components
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "10001", result.postal_code
+    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_host_configuration
+    Geocoder.configure(nominatim: {host: "local.com"})
+    query = Geocoder::Query.new("Bluffton, SC")
+    assert_match %r(http://local\.com), query.url
+  end
+
+  def test_raises_exception_when_over_query_limit
+    Geocoder.configure(:always_raise => [Geocoder::OverQueryLimitError])
+    l = Geocoder::Lookup.get(:nominatim)
+    assert_raises Geocoder::OverQueryLimitError do
+      l.send(:results, Geocoder::Query.new("over limit"))
+    end
+  end
+end

data/test/unit/lookups/smarty_streets_test.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class SmartyStreetsTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(lookup: :smarty_streets)
+    set_api_key!(:smarty_streets)
+  end
+
+  def test_url_contains_api_key
+    Geocoder.configure(:smarty_streets => {:api_key => 'blah'})
+    query = Geocoder::Query.new("Bluffton, SC")
+    assert_equal "http://api.smartystreets.com/street-address?auth-token=blah&street=Bluffton%2C+SC", query.url
+  end
+
+  def test_query_for_address_geocode
+    query = Geocoder::Query.new("42 Wallaby Way Sydney, AU")
+    assert_match /api\.smartystreets\.com\/street-address\?/, query.url
+  end
+
+  def test_query_for_zipcode_geocode
+    query = Geocoder::Query.new("22204")
+    assert_match /api\.smartystreets\.com\/zipcode\?/, query.url
+  end
+
+  def test_query_for_zipfour_geocode
+    query = Geocoder::Query.new("22204-1603")
+    assert_match /api\.smartystreets\.com\/zipcode\?/, query.url
+  end
+
+  def test_smarty_streets_result_components
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "Penn", result.street
+    assert_equal "10121", result.zipcode
+    assert_equal "1703", result.zip4
+    assert_equal "New York", result.city
+    assert_equal "36061", result.fips
+    assert !result.zipcode_endpoint?
+  end
+
+  def test_smarty_streets_result_components_with_zipcode_only_query
+    result = Geocoder.search("11211").first
+    assert_equal "Brooklyn", result.city
+    assert_equal "New York", result.state
+    assert_equal "NY", result.state_code
+    assert result.zipcode_endpoint?
+  end
+
+  def test_no_results
+    results = Geocoder.search("no results")
+    assert_equal 0, results.length
+  end
+
+  def test_raises_exception_on_error_http_status
+    error_statuses = {
+      '400' => Geocoder::InvalidRequest,
+      '401' => Geocoder::RequestDenied,
+      '402' => Geocoder::OverQueryLimitError
+    }
+    Geocoder.configure(always_raise: error_statuses.values)
+    lookup = Geocoder::Lookup.get(:smarty_streets)
+    error_statuses.each do |code, err|
+      assert_raises err do
+        response = MockHttpResponse.new(code: code.to_i)
+        lookup.send(:check_response_for_errors!, response)
+      end
+    end
+  end
+end

data/test/unit/lookups/yahoo_test.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class YahooTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(lookup: :yahoo)
+    set_api_key!(:yahoo)
+  end
+
+  def test_no_results
+    assert_equal [], Geocoder.search("no results")
+  end
+
+  def test_error
+    silence_warnings do
+      assert_equal [], Geocoder.search("error")
+    end
+  end
+
+  def test_result_components
+    result = Geocoder.search("madison square garden").first
+    assert_equal "10001", result.postal_code
+    assert_equal "Madison Square Garden, New York, NY 10001, United States", result.address
+  end
+
+  def test_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
+end

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

@@ -1,23 +1,24 @@
 # encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
 require 'test_helper'
 
-class MethodAliasesTest < Test::Unit::TestCase
+class MethodAliasesTest < GeocoderTestCase
 
   def test_distance_from_is_alias_for_distance_to
-    v = Venue.new(*venue_params(:msg))
+    v = Place.new(*geocoded_object_params(:msg))
     v.latitude, v.longitude = [40.750354, -73.993371]
     assert_equal v.distance_from([30, -94]), v.distance_to([30, -94])
   end
 
   def test_fetch_coordinates_is_alias_for_geocode
-    v = Venue.new(*venue_params(:msg))
+    v = Place.new(*geocoded_object_params(:msg))
     coords = [40.750354, -73.993371]
     assert_equal coords, v.fetch_coordinates
     assert_equal coords, [v.latitude, v.longitude]
   end
 
   def test_fetch_address_is_alias_for_reverse_geocode
-    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.fetch_address
     assert_equal address, v.address

data/test/unit/model_test.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class ModelTest < GeocoderTestCase
+
+  def test_geocode_with_block_runs_block
+    e = PlaceWithCustomResultsHandling.new(*geocoded_object_params(:msg))
+    coords = [40.750354, -73.993371]
+    e.geocode
+    assert_equal coords.map{ |c| c.to_s }.join(','), e.coords_string
+  end
+
+  def test_geocode_with_block_doesnt_auto_assign_coordinates
+    e = PlaceWithCustomResultsHandling.new(*geocoded_object_params(:msg))
+    e.geocode
+    assert_nil e.latitude
+    assert_nil e.longitude
+  end
+
+  def test_reverse_geocode_with_block_runs_block
+    e = PlaceReverseGeocodedWithCustomResultsHandling.new(*reverse_geocoded_object_params(:msg))
+    e.reverse_geocode
+    assert_equal "US", e.country
+  end
+
+  def test_reverse_geocode_with_block_doesnt_auto_assign_address
+    e = PlaceReverseGeocodedWithCustomResultsHandling.new(*reverse_geocoded_object_params(:msg))
+    e.reverse_geocode
+    assert_nil e.address
+  end
+
+  def test_units_and_method
+    PlaceReverseGeocoded.reverse_geocoded_by :latitude, :longitude, method: :spherical, units: :km
+    assert_equal :km,        PlaceReverseGeocoded.geocoder_options[:units]
+    assert_equal :spherical, PlaceReverseGeocoded.geocoder_options[:method]
+  end
+end