bw-geocoder 1.2.5

data/test/unit/lookups/opencagedata_test.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class OpencagedataTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(lookup: :opencagedata)
+    set_api_key!(:opencagedata)
+  end
+
+  def test_result_components
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "West 31st Street", result.street
+    assert_match /46, West 31st Street, Koreatown, New York County, 10011, New York City, New York, United States of America/, result.address
+
+  end
+
+  def test_opencagedata_query_url_contains_bounds
+    lookup = Geocoder::Lookup::Opencagedata.new
+    url = lookup.query_url(Geocoder::Query.new(
+      "Some street",
+      :bounds => [[40.0, -120.0], [39.0, -121.0]]
+    ))
+    assert_match(/bounds=40.0+%2C-120.0+%2C39.0+%2C-121.0+/, url)
+  end
+
+
+  def test_no_results
+    results = Geocoder.search("no results")
+    assert_equal 0, results.length
+  end
+
+
+  def test_opencagedata_reverse_url
+    query = Geocoder::Query.new([45.423733, -75.676333])
+    assert_match /\bq=45.423733%2C-75.676333\b/, query.url
+  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_over_query_limit
+    Geocoder.configure(:always_raise => [Geocoder::OverQueryLimitError])
+    l = Geocoder::Lookup.get(:opencagedata)
+    assert_raises Geocoder::OverQueryLimitError do
+      l.send(:results, Geocoder::Query.new("over limit"))
+    end
+  end
+end

data/test/unit/lookups/pointpin_test.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class PointpinTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(ip_lookup: :pointpin, api_key: "abc123")
+  end
+
+  def test_result_on_ip_address_search
+    result = Geocoder.search("80.111.555.555").first
+    assert result.is_a?(Geocoder::Result::Pointpin)
+  end
+
+  def test_result_components
+    result = Geocoder.search("80.111.555.555").first
+    assert_equal "Dublin, Dublin City, 8, Ireland", result.address
+  end
+
+  def test_no_results
+    results = Geocoder.search("10.10.10.10")
+    assert_equal 0, results.length
+  end
+
+  def test_invalid_address
+    results = Geocoder.search("555.555.555.555")
+    assert_equal 0, results.length
+  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/telize_test.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..", "..")
+require 'test_helper'
+
+class TelizeTest < GeocoderTestCase
+
+  def setup
+    Geocoder.configure(ip_lookup: :telize)
+  end
+
+  def test_result_on_ip_address_search
+    result = Geocoder.search("74.200.247.59").first
+    assert result.is_a?(Geocoder::Result::Telize)
+  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_no_results
+    results = Geocoder.search("10.10.10.10")
+    assert_equal 0, results.length
+  end
+
+  def test_invalid_address
+    results = Geocoder.search("555.555.555.555")
+    assert_equal 0, results.length
+  end
+
+  def test_uses_http_even_if_use_https_true
+    Geocoder.configure(use_https: true)
+    result = Geocoder.search("74.200.247.59").first
+    assert result.is_a?(Geocoder::Result::Telize)
+  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/unit/method_aliases_test.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class MethodAliasesTest < GeocoderTestCase
+
+  def test_distance_from_is_alias_for_distance_to
+    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 = 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 = 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
+  end
+end

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

data/test/unit/mongoid_test.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'mongoid_test_helper'
+
+class MongoidTest < GeocoderTestCase
+  def test_geocoded_check
+    p = PlaceUsingMongoid.new(*geocoded_object_params(:msg))
+    p.location = [40.750354, -73.993371]
+    assert p.geocoded?
+  end
+
+  def test_distance_to_returns_float
+    p = PlaceUsingMongoid.new(*geocoded_object_params(:msg))
+    p.location = [40.750354, -73.993371]
+    assert p.distance_to([30, -94]).is_a?(Float)
+  end
+
+  def test_custom_coordinate_field_near_scope
+    location = [40.750354, -73.993371]
+    p = PlaceUsingMongoid.near(location)
+    key = Mongoid::VERSION >= "3" ? "location" : :location
+    assert_equal p.selector[key]['$nearSphere'], location.reverse
+  end
+
+  def test_model_configuration
+    p = PlaceUsingMongoid.new(*geocoded_object_params(:msg))
+    p.location = [0, 0]
+
+    PlaceUsingMongoid.geocoded_by :address, :coordinates => :location, :units => :km
+    assert_equal 111, p.distance_to([0,1]).round
+
+    PlaceUsingMongoid.geocoded_by :address, :coordinates => :location, :units => :mi
+    assert_equal 69, p.distance_to([0,1]).round
+  end
+
+  def test_index_is_skipped_if_skip_option_flag
+    result = PlaceUsingMongoidWithoutIndex.index_options.keys.flatten[0] == :coordinates
+    assert !result
+  end
+
+  def test_nil_radius_omits_max_distance
+    location = [40.750354, -73.993371]
+    p = PlaceUsingMongoid.near(location, nil)
+    key = Mongoid::VERSION >= "3" ? "location" : :location
+    assert_equal nil, p.selector[key]['$maxDistance']
+  end
+end

data/test/unit/near_test.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class NearTest < GeocoderTestCase
+
+  def test_near_scope_options_without_sqlite_includes_bounding_box_condition
+    result = PlaceWithCustomResultsHandling.send(:near_scope_options, 1.0, 2.0, 5)
+    assert_match(/test_table_name.latitude BETWEEN 0.9276\d* AND 1.0723\d* AND test_table_name.longitude BETWEEN 1.9276\d* AND 2.0723\d* AND /, result[:conditions][0])
+  end
+
+  def test_near_scope_options_without_sqlite_includes_radius_condition
+    result = Place.send(:near_scope_options, 1.0, 2.0, 5)
+    assert_match(/BETWEEN \? AND \?$/, result[:conditions][0])
+  end
+
+  def test_near_scope_options_without_sqlite_includes_radius_default_min_radius
+    result = Place.send(:near_scope_options, 1.0, 2.0, 5)
+
+    assert_equal(0, result[:conditions][1])
+    assert_equal(5, result[:conditions][2])
+  end
+
+  def test_near_scope_options_without_sqlite_includes_radius_custom_min_radius
+    result = Place.send(:near_scope_options, 1.0, 2.0, 5, :min_radius => 3)
+
+    assert_equal(3, result[:conditions][1])
+    assert_equal(5, result[:conditions][2])
+  end
+
+  def test_near_scope_options_without_sqlite_includes_radius_bogus_min_radius
+    result = Place.send(:near_scope_options, 1.0, 2.0, 5, :min_radius => 'bogus')
+
+    assert_equal(0, result[:conditions][1])
+    assert_equal(5, result[:conditions][2])
+  end
+
+  def test_near_scope_options_with_defaults
+    result = PlaceWithCustomResultsHandling.send(:near_scope_options, 1.0, 2.0, 5)
+
+    assert_match(/AS distance/, result[:select])
+    assert_match(/AS bearing/, result[:select])
+    assert_no_consecutive_comma(result[:select])
+  end
+
+  def test_near_scope_options_with_no_distance
+    result = PlaceWithCustomResultsHandling.send(:near_scope_options, 1.0, 2.0, 5, :select_distance => false)
+
+    assert_no_match(/AS distance/, result[:select])
+    assert_match(/AS bearing/, result[:select])
+    assert_no_match(/distance/, result[:condition])
+    assert_no_match(/distance/, result[:order])
+    assert_no_consecutive_comma(result[:select])
+  end
+
+  def test_near_scope_options_with_no_bearing
+    result = PlaceWithCustomResultsHandling.send(:near_scope_options, 1.0, 2.0, 5, :select_bearing => false)
+
+    assert_match(/AS distance/, result[:select])
+    assert_no_match(/AS bearing/, result[:select])
+    assert_no_consecutive_comma(result[:select])
+  end
+
+  def test_near_scope_options_with_custom_distance_column
+    result = PlaceWithCustomResultsHandling.send(:near_scope_options, 1.0, 2.0, 5, :distance_column => 'calculated_distance')
+
+    assert_no_match(/AS distance/, result[:select])
+    assert_match(/AS calculated_distance/, result[:select])
+    assert_no_match(/\bdistance\b/, result[:order])
+    assert_match(/calculated_distance/, result[:order])
+    assert_no_consecutive_comma(result[:select])
+  end
+
+  def test_near_scope_options_with_custom_bearing_column
+    result = PlaceWithCustomResultsHandling.send(:near_scope_options, 1.0, 2.0, 5, :bearing_column => 'calculated_bearing')
+
+    assert_no_match(/AS bearing/, result[:select])
+    assert_match(/AS calculated_bearing/, result[:select])
+    assert_no_consecutive_comma(result[:select])
+  end
+
+  private
+
+  def assert_no_consecutive_comma(string)
+    assert_no_match(/, *,/, string, "two consecutive commas")
+  end
+end

data/test/unit/oauth_util_test.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+require 'cgi'
+require 'uri'
+
+class OauthUtilTest < GeocoderTestCase
+  def test_query_string_escapes_single_quote
+    base_url = "http://example.com?location=d'iberville"
+
+    o = OauthUtil.new
+    o.consumer_key = 'consumer_key'
+    o.consumer_secret = 'consumer_secret'
+
+    query_string = o.sign(URI.parse(base_url)).query_string
+
+    assert_match "location=d%27iberville", query_string
+  end
+
+  def test_query_string_sorts_url_keys
+    base_url = "http://example.com?a_param=a&z_param=b&b_param=c&n_param=d"
+
+    o = OauthUtil.new
+    o.consumer_key = 'consumer_key'
+    o.consumer_secret = 'consumer_secret'
+
+    query_string = o.sign(URI.parse(base_url)).query_string
+
+    assert_match(/.*a_param=.*b_param=.*n_param=.*z_param=.*/, query_string)
+  end
+end

data/test/unit/proxy_test.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class ProxyTest < GeocoderTestCase
+
+  def test_uses_proxy_when_specified
+    Geocoder.configure(:http_proxy => 'localhost')
+    lookup = Geocoder::Lookup::Google.new
+    assert lookup.send(:http_client).proxy_class?
+  end
+
+  def test_doesnt_use_proxy_when_not_specified
+    lookup = Geocoder::Lookup::Google.new
+    assert !lookup.send(:http_client).proxy_class?
+  end
+
+  def test_exception_raised_on_bad_proxy_url
+    Geocoder.configure(:http_proxy => ' \\_O< Quack Quack')
+    assert_raise Geocoder::ConfigurationError do
+      Geocoder::Lookup::Google.new.send(:http_client)
+    end
+  end
+
+  def test_accepts_proxy_with_http_protocol
+    Geocoder.configure(:http_proxy => 'http://localhost')
+    lookup = Geocoder::Lookup::Google.new
+    assert lookup.send(:http_client).proxy_class?
+  end
+
+  def test_accepts_proxy_with_https_protocol
+    Geocoder.configure(:https_proxy => 'https://localhost')
+    Geocoder.configure(:use_https => true)
+    lookup = Geocoder::Lookup::Google.new
+    assert lookup.send(:http_client).proxy_class?
+  end
+end

data/test/unit/query_test.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class QueryTest < GeocoderTestCase
+
+  def test_ip_address_detection
+    assert Geocoder::Query.new("232.65.123.94").ip_address?
+    assert Geocoder::Query.new("3ffe:0b00:0000:0000:0001:0000:0000:000a").ip_address?
+    assert !Geocoder::Query.new("232.65.123.94.43").ip_address?
+    assert !Geocoder::Query.new("::ffff:123.456.789").ip_address?
+  end
+
+  def test_blank_query_detection
+    assert Geocoder::Query.new(nil).blank?
+    assert Geocoder::Query.new("").blank?
+    assert Geocoder::Query.new("\t  ").blank?
+    assert !Geocoder::Query.new("a").blank?
+    assert !Geocoder::Query.new("Москва").blank? # no ASCII characters
+    assert !Geocoder::Query.new("\na").blank?
+
+    assert Geocoder::Query.new(nil, :params => {}).blank?
+    assert !Geocoder::Query.new(nil, :params => {:woeid => 1234567}).blank?
+  end
+
+  def test_blank_query_detection_for_coordinates
+    assert Geocoder::Query.new([nil,nil]).blank?
+    assert Geocoder::Query.new([87,nil]).blank?
+  end
+
+  def test_coordinates_detection
+    assert Geocoder::Query.new("51.178844,5").coordinates?
+    assert Geocoder::Query.new("51.178844, -1.826189").coordinates?
+    assert !Geocoder::Query.new("232.65.123").coordinates?
+    assert !Geocoder::Query.new("Test\n51.178844, -1.826189").coordinates?
+  end
+
+  def test_loopback_ip_address
+    assert Geocoder::Query.new("127.0.0.1").loopback_ip_address?
+    assert !Geocoder::Query.new("232.65.123.234").loopback_ip_address?
+  end
+
+  def test_sanitized_text_with_array
+    q = Geocoder::Query.new([43.1313,11.3131])
+    assert_equal "43.1313,11.3131", q.sanitized_text
+  end
+
+  def test_custom_lookup
+    query = Geocoder::Query.new("address", :lookup => :nominatim)
+    assert_equal Geocoder::Lookup::Nominatim, query.lookup.class
+  end
+end

data/test/unit/rake_task_test.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class RakeTaskTest < GeocoderTestCase
+  def setup
+    Rake.application.rake_require "tasks/geocoder"
+    Rake::Task.define_task(:environment)
+  end
+
+  def test_rake_task_geocode_raise_specify_class_message
+    assert_raise(RuntimeError, "Please specify a CLASS (model)") do
+      Rake.application.invoke_task("geocode:all")
+    end
+  end
+
+  def test_rake_task_geocode_specify_class
+    ENV['CLASS'] = 'Place'
+    assert_nil Rake.application.invoke_task("geocode:all")
+  end
+end

data/test/unit/request_test.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class RequestTest < GeocoderTestCase
+  class MockRequest
+    include Geocoder::Request
+    attr_accessor :env, :ip
+    def initialize(env={}, ip="")
+      @env = env
+      @ip  = ip
+    end
+  end
+  def test_http_x_real_ip
+    req = MockRequest.new({"HTTP_X_REAL_IP" => "74.200.247.59"})
+    assert req.location.is_a?(Geocoder::Result::Freegeoip)
+  end
+  def test_http_x_forwarded_for_without_proxy
+    req = MockRequest.new({"HTTP_X_FORWARDED_FOR" => "74.200.247.59"})
+    assert req.location.is_a?(Geocoder::Result::Freegeoip)
+  end
+  def test_http_x_forwarded_for_with_proxy
+    req = MockRequest.new({"HTTP_X_FORWARDED_FOR" => "74.200.247.59, 74.200.247.59"})
+    assert req.location.is_a?(Geocoder::Result::Freegeoip)
+  end
+  def test_with_request_ip
+    req = MockRequest.new({}, "74.200.247.59")
+    assert req.location.is_a?(Geocoder::Result::Freegeoip)
+  end
+
+  def test_with_loopback_x_forwarded_for
+    req = MockRequest.new({"HTTP_X_FORWARDED_FOR" => "127.0.0.1"}, "74.200.247.59")
+    assert_equal "US", req.location.country_code
+  end
+end