geocoder2 0.1.0

data/test/integration/smoke_test.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), *%w[ .. .. lib]))
+require 'pathname'
+require 'rubygems'
+require 'test/unit'
+require 'geocoder2'
+
+class SmokeTest < Test::Unit::TestCase
+
+  def test_simple_zip_code_search
+    result = Geocoder2.search "27701"
+    assert_not_nil (r = result.first)
+    assert_equal "Durham", r.city
+    assert_equal "North Carolina", r.state
+  end
+
+  def test_simple_zip_code_search_with_ssl
+    Geocoder2.configure(:use_https => true)
+    result = Geocoder2.search "27701"
+    assert_not_nil (r = result.first)
+    assert_equal "Durham", r.city
+    assert_equal "North Carolina", r.state
+  ensure
+    Geocoder2.configure(:use_https => false)
+  end
+
+end

data/test/lookup_test.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+require 'test_helper'
+
+class LookupTest < Test::Unit::TestCase
+
+  def test_responds_to_name_method
+    Geocoder2::Lookup.all_services.each do |l|
+      lookup = Geocoder2::Lookup.get(l)
+      assert lookup.respond_to?(:name),
+        "Lookup #{l} does not respond to #name method."
+    end
+  end
+
+  def test_search_returns_empty_array_when_no_results
+    Geocoder2::Lookup.all_services_except_test.each do |l|
+      lookup = Geocoder2::Lookup.get(l)
+      set_api_key!(l)
+      assert_equal [], lookup.send(:results, Geocoder2::Query.new("no results")),
+        "Lookup #{l} does not return empty array when no results."
+    end
+  end
+
+  def test_query_url_contains_values_in_params_hash
+    Geocoder2::Lookup.all_services_except_test.each do |l|
+      next if l == :freegeoip # does not use query string
+      set_api_key!(l)
+      url = Geocoder2::Lookup.get(l).query_url(Geocoder2::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
+
+  {
+    :esri => :l,
+    :bing => :key,
+    :geocoder_ca => :auth,
+    :google => :language,
+    :google_premier => :language,
+    :mapquest => :key,
+    :maxmind => :l,
+    :nominatim => :"accept-language",
+    :yahoo => :locale,
+    :yandex => :plng
+  }.each do |l,p|
+    define_method "test_passing_param_to_#{l}_query_overrides_configuration_value" do
+      set_api_key!(l)
+      url = Geocoder2::Lookup.get(l).query_url(Geocoder2::Query.new(
+        "test", :params => {p => "xxxx"}
+      ))
+      assert_match /#{p}=xxxx/, url,
+        "Param passed to #{l} lookup does not override configuration value"
+    end
+  end
+
+  def test_raises_exception_on_invalid_key
+    Geocoder2.configure(:always_raise => [Geocoder2::InvalidApiKey])
+    #Geocoder2::Lookup.all_services_except_test.each do |l|
+    [:bing, :yahoo, :yandex, :maxmind].each do |l|
+      lookup = Geocoder2::Lookup.get(l)
+      assert_raises Geocoder2::InvalidApiKey do
+        lookup.send(:results, Geocoder2::Query.new("invalid key"))
+      end
+    end
+  end
+
+  def test_returns_empty_array_on_invalid_key
+    # keep test output clean: suppress timeout warning
+    orig = $VERBOSE; $VERBOSE = nil
+    #Geocoder2::Lookup.all_services_except_test.each do |l|
+    [:bing, :yahoo, :yandex, :maxmind].each do |l|
+      Geocoder2.configure(:lookup => l)
+      set_api_key!(l)
+      assert_equal [], Geocoder2.search("invalid key")
+    end
+  ensure
+    $VERBOSE = orig
+  end
+
+  def test_does_not_choke_on_nil_address
+    Geocoder2::Lookup.all_services.each do |l|
+      Geocoder2.configure(:lookup => l)
+      assert_nothing_raised { Venue.new("Venue", nil).geocode }
+    end
+  end
+
+  def test_hash_to_query
+    g = Geocoder2::Lookup::Google.new
+    assert_equal "a=1&b=2", g.send(:hash_to_query, {:a => 1, :b => 2})
+  end
+
+  def test_google_api_key
+    Geocoder2.configure(:api_key => "MY_KEY")
+    g = Geocoder2::Lookup::Google.new
+    assert_match "key=MY_KEY", g.query_url(Geocoder2::Query.new("Madison Square Garden, New York, NY  10001, United States"))
+  end
+
+  def test_geocoder_ca_showpostal
+    Geocoder2.configure(:api_key => "MY_KEY")
+    g = Geocoder2::Lookup::GeocoderCa.new
+    assert_match "showpostal=1", g.query_url(Geocoder2::Query.new("Madison Square Garden, New York, NY  10001, United States"))
+  end
+
+  def test_raises_configuration_error_on_missing_key
+    assert_raises Geocoder2::ConfigurationError do
+      Geocoder2.configure(:lookup => :bing, :api_key => nil)
+      Geocoder2.search("Madison Square Garden, New York, NY  10001, United States")
+    end
+  end
+
+  def test_handle
+    assert_equal :google, Geocoder2::Lookup::Google.new.handle
+    assert_equal :geocoder_ca, Geocoder2::Lookup::GeocoderCa.new.handle
+  end
+end

data/test/method_aliases_test.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'test_helper'
+
+class MethodAliasesTest < Test::Unit::TestCase
+
+  def test_distance_from_is_alias_for_distance_to
+    v = Venue.new(*venue_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))
+    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))
+    address = "4 Penn Plaza, New York, NY 10001, USA"
+    assert_equal address, v.fetch_address
+    assert_equal address, v.address
+  end
+end

data/test/mongoid_test.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+require 'mongoid_test_helper'
+
+class MongoidTest < Test::Unit::TestCase
+  def test_geocoded_check
+    p = Place.new(*venue_params(:msg))
+    p.location = [40.750354, -73.993371]
+    assert p.geocoded?
+  end
+
+  def test_distance_to_returns_float
+    p = Place.new(*venue_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 = Place.near(location)
+    key = Mongoid::VERSION >= "3" ? "location" : :location
+    assert_equal p.selector[key]['$nearSphere'], location.reverse
+  end
+
+  def test_model_configuration
+    p = Place.new(*venue_params(:msg))
+    p.location = [0, 0]
+
+    Place.geocoded_by :address, :coordinates => :location, :units => :km
+    assert_equal 111, p.distance_to([0,1]).round
+
+    Place.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 = PlaceWithoutIndex.index_options.keys.flatten[0] == :coordinates
+    assert !result
+  end
+
+  def test_nil_radius_omits_max_distance
+    location = [40.750354, -73.993371]
+    p = Place.near(location, nil)
+    key = Mongoid::VERSION >= "3" ? "location" : :location
+    assert_equal nil, p.selector[key]['$maxDistance']
+  end
+end

data/test/mongoid_test_helper.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'test/unit'
+require 'test_helper'
+require 'mongoid'
+require 'geocoder2/models/mongoid'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+if (::Mongoid::VERSION >= "3")
+  Mongoid.logger = Logger.new($stderr, :debug)
+else
+  Mongoid.configure do |config|
+    config.logger = Logger.new($stderr, :debug)
+  end
+end
+
+##
+# Geocoded model.
+#
+class Place
+  include Mongoid::Document
+  include Geocoder2::Model::Mongoid
+
+  geocoded_by :address, :coordinates => :location
+  field :name
+  field :address
+  field :location, :type => Array
+
+  def initialize(name, address)
+    super()
+    write_attribute :name, name
+    write_attribute :address, address
+  end
+end
+
+class PlaceWithoutIndex
+  include Mongoid::Document
+  include Geocoder2::Model::Mongoid
+
+  field :location, :type => Array
+  geocoded_by :location, :skip_index => true
+end

data/test/near_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+class NearTest < Test::Unit::TestCase
+
+  def test_near_scope_options_without_sqlite_includes_bounding_box_condition
+    result = Event.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_with_defaults
+    result = Event.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 = Event.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 = Event.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 = Event.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 = Event.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/oauth_util_test.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require 'test_helper'
+require 'cgi'
+require 'uri'
+
+class OauthUtilTest < Test::Unit::TestCase
+  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/proxy_test.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+require 'test_helper'
+
+class ProxyTest < Test::Unit::TestCase
+
+  def test_uses_proxy_when_specified
+    Geocoder2.configure(:http_proxy => 'localhost')
+    lookup = Geocoder2::Lookup::Google.new
+    assert lookup.send(:http_client).proxy_class?
+  end
+
+  def test_doesnt_use_proxy_when_not_specified
+    lookup = Geocoder2::Lookup::Google.new
+    assert !lookup.send(:http_client).proxy_class?
+  end
+
+  def test_exception_raised_on_bad_proxy_url
+    Geocoder2.configure(:http_proxy => ' \\_O< Quack Quack')
+    assert_raise Geocoder2::ConfigurationError do
+      Geocoder2::Lookup::Google.new.send(:http_client)
+    end
+  end
+
+  def test_accepts_proxy_with_http_protocol
+    Geocoder2.configure(:http_proxy => 'http://localhost')
+    lookup = Geocoder2::Lookup::Google.new
+    assert lookup.send(:http_client).proxy_class?
+  end
+
+  def test_accepts_proxy_with_https_protocol
+    Geocoder2.configure(:https_proxy => 'https://localhost')
+    Geocoder2.configure(:use_https => true)
+    lookup = Geocoder2::Lookup::Google.new
+    assert lookup.send(:http_client).proxy_class?
+  end
+end

data/test/query_test.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+require 'test_helper'
+
+class QueryTest < Test::Unit::TestCase
+
+  def test_ip_address_detection
+    assert Geocoder2::Query.new("232.65.123.94").ip_address?
+    assert Geocoder2::Query.new("666.65.123.94").ip_address? # technically invalid
+    assert Geocoder2::Query.new("::ffff:12.34.56.78").ip_address?
+    assert !Geocoder2::Query.new("232.65.123.94.43").ip_address?
+    assert !Geocoder2::Query.new("232.65.123").ip_address?
+    assert !Geocoder2::Query.new("::ffff:123.456.789").ip_address?
+    assert !Geocoder2::Query.new("Test\n232.65.123.94").ip_address?
+  end
+
+  def test_blank_query_detection
+    assert Geocoder2::Query.new(nil).blank?
+    assert Geocoder2::Query.new("").blank?
+    assert Geocoder2::Query.new("\t  ").blank?
+    assert !Geocoder2::Query.new("a").blank?
+    assert !Geocoder2::Query.new("Москва").blank? # no ASCII characters
+    assert !Geocoder2::Query.new("\na").blank?
+
+    assert Geocoder2::Query.new(nil, :params => {}).blank?
+    assert !Geocoder2::Query.new(nil, :params => {:woeid => 1234567}).blank?
+  end
+
+  def test_blank_query_detection_for_coordinates
+    assert Geocoder2::Query.new([nil,nil]).blank?
+    assert Geocoder2::Query.new([87,nil]).blank?
+  end
+
+  def test_coordinates_detection
+    assert Geocoder2::Query.new("51.178844,5").coordinates?
+    assert Geocoder2::Query.new("51.178844, -1.826189").coordinates?
+    assert !Geocoder2::Query.new("232.65.123").coordinates?
+    assert !Geocoder2::Query.new("Test\n51.178844, -1.826189").coordinates?
+  end
+
+  def test_loopback_ip_address
+    assert Geocoder2::Query.new("0.0.0.0").loopback_ip_address?
+    assert Geocoder2::Query.new("127.0.0.1").loopback_ip_address?
+    assert !Geocoder2::Query.new("232.65.123.234").loopback_ip_address?
+    assert !Geocoder2::Query.new("127 Main St.").loopback_ip_address?
+    assert !Geocoder2::Query.new("John Doe\n127 Main St.\nAnywhere, USA").loopback_ip_address?
+  end
+
+  def test_sanitized_text_with_array
+    q = Geocoder2::Query.new([43.1313,11.3131])
+    assert_equal "43.1313,11.3131", q.sanitized_text
+  end
+end

data/test/request_test.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require 'test_helper'
+
+class RequestTest < Test::Unit::TestCase
+  class MockRequest
+    include Geocoder2::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?(Geocoder2::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?(Geocoder2::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?(Geocoder2::Result::Freegeoip)
+  end
+  def test_with_request_ip
+    req = MockRequest.new({}, "74.200.247.59")
+    assert req.location.is_a?(Geocoder2::Result::Freegeoip)
+  end
+end

data/test/result_test.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+require 'test_helper'
+
+class ResultTest < Test::Unit::TestCase
+
+  def test_result_has_required_attributes
+    Geocoder2::Lookup.all_services_except_test.each do |l|
+      Geocoder2.configure(:lookup => l)
+      set_api_key!(l)
+      result = Geocoder2.search([45.423733, -75.676333]).first
+      assert_result_has_required_attributes(result)
+    end
+  end
+
+  def test_yandex_result_without_city_does_not_raise_exception
+    assert_nothing_raised do
+      Geocoder2.configure(:lookup => :yandex)
+      set_api_key!(:yandex)
+      result = Geocoder2.search("no city and town").first
+      assert_equal "", result.city
+    end
+  end
+
+
+  private # ------------------------------------------------------------------
+
+  def assert_result_has_required_attributes(result)
+    m = "Lookup #{Geocoder2.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"
+    assert result.city.is_a?(String),          m % "city"
+    assert result.state.is_a?(String),         m % "state"
+    assert result.state_code.is_a?(String),    m % "state_code"
+    assert result.province.is_a?(String),      m % "province"
+    assert result.province_code.is_a?(String), m % "province_code"
+    assert result.postal_code.is_a?(String),   m % "postal_code"
+    assert result.country.is_a?(String),       m % "country"
+    assert result.country_code.is_a?(String),  m % "country_code"
+    assert_not_nil result.address,             m % "address"
+  end
+end