bw-geocoder 1.2.5

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

data/test/unit/lookups/google_places_details_test.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class GooglePlacesDetailsTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(lookup: :google_places_details)
+    set_api_key!(:google_places_details)
+  end
+
+  def test_google_places_details_result_components
+    assert_equal "Manhattan", madison_square_garden.address_components_of_type(:sublocality).first["long_name"]
+  end
+
+  def test_google_places_details_result_components_contains_route
+    assert_equal "Pennsylvania Plaza", madison_square_garden.address_components_of_type(:route).first["long_name"]
+  end
+
+  def test_google_places_details_result_components_contains_street_number
+    assert_equal "4", madison_square_garden.address_components_of_type(:street_number).first["long_name"]
+  end
+
+  def test_google_places_details_street_address_returns_formatted_street_address
+    assert_equal "4 Pennsylvania Plaza", madison_square_garden.street_address
+  end
+
+  def test_google_places_details_result_contains_place_id
+    assert_equal "ChIJhRwB-yFawokR5Phil-QQ3zM", madison_square_garden.place_id
+  end
+
+  def test_google_places_details_result_contains_latitude
+    assert_equal madison_square_garden.latitude, 40.750504
+  end
+
+  def test_google_places_details_result_contains_longitude
+    assert_equal madison_square_garden.longitude, -73.993439
+  end
+
+  def test_google_places_details_result_contains_rating
+    assert_equal 4.4, madison_square_garden.rating
+  end
+
+  def test_google_places_details_result_contains_rating_count
+    assert_equal 382, madison_square_garden.rating_count
+  end
+
+  def test_google_places_details_result_contains_reviews
+    reviews = madison_square_garden.reviews
+
+    assert_equal 2, reviews.size
+    assert_equal "John Smith", reviews.first["author_name"]
+    assert_equal 5, reviews.first["rating"]
+    assert_equal "It's nice.", reviews.first["text"]
+    assert_equal "en", reviews.first["language"]
+  end
+
+  def test_google_places_details_result_contains_types
+    assert_equal madison_square_garden.types, %w(stadium establishment)
+  end
+
+  def test_google_places_details_result_contains_website
+    assert_equal madison_square_garden.website, "http://www.thegarden.com/"
+  end
+
+  def test_google_places_details_result_contains_phone_number
+    assert_equal madison_square_garden.phone_number, "+1 212-465-6741"
+  end
+
+  def test_google_places_details_query_url_contains_placeid
+    url = lookup.query_url(Geocoder::Query.new("some-place-id"))
+    assert_match(/placeid=some-place-id/, url)
+  end
+
+  def test_google_places_details_query_url_contains_language
+    url = lookup.query_url(Geocoder::Query.new("some-place-id", language: "de"))
+    assert_match(/language=de/, url)
+  end
+
+  def test_google_places_details_query_url_always_uses_https
+    url = lookup.query_url(Geocoder::Query.new("some-place-id"))
+    assert_match(%r(^https://), url)
+  end
+
+  def test_google_places_details_result_with_no_reviews_shows_empty_reviews
+    assert_equal no_reviews_result.reviews, []
+  end
+
+  def test_google_places_details_result_with_no_types_shows_empty_types
+    assert_equal no_types_result.types, []
+  end
+
+  def test_google_places_details_result_with_invalid_place_id_empty
+    assert_equal Geocoder.search("invalid request"), []
+  end
+
+  def test_raises_exception_on_google_places_details_invalid_request
+    Geocoder.configure(always_raise: [Geocoder::InvalidRequest])
+    assert_raises Geocoder::InvalidRequest do
+      Geocoder.search("invalid request")
+    end
+  end
+
+  private
+
+  def lookup
+    Geocoder::Lookup::GooglePlacesDetails.new
+  end
+
+  def madison_square_garden
+    Geocoder.search("ChIJhRwB-yFawokR5Phil-QQ3zM").first
+  end
+
+  def no_reviews_result
+    Geocoder.search("no reviews").first
+  end
+
+  def no_types_result
+    Geocoder.search("no types").first
+  end
+
+end

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/okf_test.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class OkfTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(lookup: :okf)
+  end
+
+  def test_okf_result_components
+    result = Geocoder.search("Kirstinmäki 11b28").first
+    assert_equal "Espoo",
+      result.address_components_of_type(:administrative_area_level_3).first['long_name']
+  end
+
+  def test_okf_result_components_contains_route
+    result = Geocoder.search("Kirstinmäki 11b28").first
+    assert_equal "Kirstinmäki",
+      result.address_components_of_type(:route).first['long_name']
+  end
+
+  def test_okf_result_components_contains_street_number
+    result = Geocoder.search("Kirstinmäki 11b28").first
+    assert_equal "1",
+      result.address_components_of_type(:street_number).first['long_name']
+  end
+
+  def test_okf_street_address_returns_formatted_street_address
+    result = Geocoder.search("Kirstinmäki 11b28").first
+    assert_equal "Kirstinmäki 1", result.street_address
+  end
+
+  def test_okf_precision
+    result = Geocoder.search("Kirstinmäki 11b28").first
+    assert_equal "RANGE_INTERPOLATED", result.precision
+  end
+end