geocoder-kb 1.2.6

data/test/unit/active_record_test.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class ActiveRecordTest < GeocoderTestCase
+
+  def test_exclude_condition_when_model_has_a_custom_primary_key
+    venue = PlaceWithCustomPrimaryKey.new(*geocoded_object_params(:msg))
+
+    # just call private method directly so we don't have to stub .near scope
+    conditions = venue.class.send(:add_exclude_condition, ["fake_condition"], venue)
+
+    assert_match( /#{PlaceWithCustomPrimaryKey.primary_key}/, conditions.join)
+  end
+
+end

data/test/unit/cache_test.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class CacheTest < GeocoderTestCase
+
+  def test_second_occurrence_of_request_is_cache_hit
+    Geocoder.configure(:cache => {})
+    Geocoder::Lookup.all_services_except_test.each do |l|
+      next if l == :maxmind_local || l == :geoip2 # local, does not use cache
+      Geocoder.configure(:lookup => l)
+      set_api_key!(l)
+      results = Geocoder.search("Madison Square Garden")
+      assert !results.first.cache_hit,
+        "Lookup #{l} returned erroneously cached result."
+      results = Geocoder.search("Madison Square Garden")
+      assert results.first.cache_hit,
+        "Lookup #{l} did not return cached result."
+    end
+  end
+
+  def test_google_over_query_limit_does_not_hit_cache
+    Geocoder.configure(:cache => {})
+    Geocoder.configure(:lookup => :google)
+    set_api_key!(:google)
+    Geocoder.configure(:always_raise => :all)
+    assert_raises Geocoder::OverQueryLimitError do
+      Geocoder.search("over limit")
+    end
+    lookup = Geocoder::Lookup.get(:google)
+    assert_equal false, lookup.instance_variable_get(:@cache_hit)
+    assert_raises Geocoder::OverQueryLimitError do
+      Geocoder.search("over limit")
+    end
+    assert_equal false, lookup.instance_variable_get(:@cache_hit)
+  end
+end

data/test/unit/calculations_test.rb

@@ -0,0 +1,220 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class CalculationsTest < GeocoderTestCase
+  def setup
+    Geocoder.configure(
+      :units => :mi,
+      :distances => :linear
+    )
+  end
+
+  # --- degree distance ---
+
+  def test_longitude_degree_distance_at_equator
+    assert_equal 69, Geocoder::Calculations.longitude_degree_distance(0).round
+  end
+
+  def test_longitude_degree_distance_at_new_york
+    assert_equal 53, Geocoder::Calculations.longitude_degree_distance(40).round
+  end
+
+  def test_longitude_degree_distance_at_north_pole
+    assert_equal 0, Geocoder::Calculations.longitude_degree_distance(89.98).round
+  end
+
+
+  # --- distance between ---
+
+  def test_distance_between_in_miles
+    assert_equal 69, Geocoder::Calculations.distance_between([0,0], [0,1]).round
+    la_to_ny = Geocoder::Calculations.distance_between([34.05,-118.25], [40.72,-74]).round
+    assert (la_to_ny - 2444).abs < 10
+  end
+
+  def test_distance_between_in_kilometers
+    assert_equal 111, Geocoder::Calculations.distance_between([0,0], [0,1], :units => :km).round
+    la_to_ny = Geocoder::Calculations.distance_between([34.05,-118.25], [40.72,-74], :units => :km).round
+    assert (la_to_ny - 3942).abs < 10
+  end
+
+  def test_distance_between_in_nautical_miles
+    assert_equal 60, Geocoder::Calculations.distance_between([0,0], [0,1], :units => :nm).round
+    la_to_ny = Geocoder::Calculations.distance_between([34.05,-118.25], [40.72,-74], :units => :nm).round
+    assert (la_to_ny - 2124).abs < 10
+  end
+
+
+  # --- geographic center ---
+
+  def test_geographic_center_with_arrays
+    assert_equal [0.0, 0.5],
+      Geocoder::Calculations.geographic_center([[0,0], [0,1]])
+    assert_equal [0.0, 1.0],
+      Geocoder::Calculations.geographic_center([[0,0], [0,1], [0,2]])
+  end
+
+  def test_geographic_center_with_mixed_arguments
+    p1 = [0, 0]
+    p2 = PlaceReverseGeocoded.new("Some Cold Place", 0, 1)
+    assert_equal [0.0, 0.5], Geocoder::Calculations.geographic_center([p1, p2])
+  end
+
+
+  # --- bounding box ---
+
+  def test_bounding_box_calculation_in_miles
+    center = [51, 7] # Cologne, DE
+    radius = 10 # miles
+    corners = [50.86, 6.77, 51.14, 7.23]
+    assert_equal corners.map{ |i| (i * 100).round },
+      Geocoder::Calculations.bounding_box(center, radius).map{ |i| (i * 100).round }
+  end
+
+  def test_bounding_box_calculation_in_kilometers
+    center = [51, 7] # Cologne, DE
+    radius = 111 # kilometers (= 1 degree latitude)
+    corners = [50, 5.41, 52, 8.59]
+    assert_equal corners.map{ |i| (i * 100).round },
+      Geocoder::Calculations.bounding_box(center, radius, :units => :km).map{ |i| (i * 100).round }
+  end
+
+  def test_bounding_box_calculation_with_object
+    center = [51, 7] # Cologne, DE
+    radius = 10 # miles
+    corners = [50.86, 6.77, 51.14, 7.23]
+    obj = PlaceReverseGeocoded.new("Cologne", center[0], center[1])
+    assert_equal corners.map{ |i| (i * 100).round },
+      Geocoder::Calculations.bounding_box(obj, radius).map{ |i| (i * 100).round }
+  end
+
+  def test_bounding_box_calculation_with_address_string
+    assert_nothing_raised do
+      Geocoder::Calculations.bounding_box("4893 Clay St, San Francisco, CA", 50)
+    end
+  end
+
+  # --- random point ---
+
+  def test_random_point_within_radius
+    20.times do
+      center = [51, 7] # Cologne, DE
+      radius = 10 # miles
+      random_point = Geocoder::Calculations.random_point_near(center, radius)
+      distance = Geocoder::Calculations.distance_between(center, random_point)
+      assert distance <= radius
+    end
+  end
+
+  # --- bearing ---
+
+  def test_compass_points
+    assert_equal "N",  Geocoder::Calculations.compass_point(0)
+    assert_equal "N",  Geocoder::Calculations.compass_point(1.0)
+    assert_equal "N",  Geocoder::Calculations.compass_point(360)
+    assert_equal "N",  Geocoder::Calculations.compass_point(361)
+    assert_equal "N",  Geocoder::Calculations.compass_point(-22)
+    assert_equal "NW", Geocoder::Calculations.compass_point(-23)
+    assert_equal "S",  Geocoder::Calculations.compass_point(180)
+    assert_equal "S",  Geocoder::Calculations.compass_point(181)
+  end
+
+  def test_bearing_between
+    bearings = {
+      :n => 0,
+      :e => 90,
+      :s => 180,
+      :w => 270
+    }
+    points = {
+      :n => [41, -75],
+      :e => [40, -74],
+      :s => [39, -75],
+      :w => [40, -76]
+    }
+    directions = [:n, :e, :s, :w]
+    methods = [:linear, :spherical]
+
+    methods.each do |m|
+      directions.each_with_index do |d,i|
+        opp = directions[(i + 2) % 4] # opposite direction
+        b = Geocoder::Calculations.bearing_between(
+          points[d], points[opp], :method => m)
+        assert (b - bearings[opp]).abs < 1,
+          "Bearing (#{m}) should be close to #{bearings[opp]} but was #{b}."
+      end
+    end
+  end
+
+  def test_spherical_bearing_to
+    l = PlaceReverseGeocoded.new(*reverse_geocoded_object_params(:msg))
+    assert_equal 324, l.bearing_to([50,-85], :method => :spherical).round
+  end
+
+  def test_spherical_bearing_from
+    l = PlaceReverseGeocoded.new(*reverse_geocoded_object_params(:msg))
+    assert_equal 136, l.bearing_from([50,-85], :method => :spherical).round
+  end
+
+  def test_linear_bearing_from_and_to_are_exactly_opposite
+    l = PlaceReverseGeocoded.new(*reverse_geocoded_object_params(:msg))
+    assert_equal l.bearing_from([50,-86.1]), l.bearing_to([50,-86.1]) - 180
+  end
+
+  def test_extract_coordinates
+    coords = [-23,47]
+    l = PlaceReverseGeocoded.new("Madagascar", coords[0], coords[1])
+    assert_equal coords, Geocoder::Calculations.extract_coordinates(l)
+    assert_equal coords, Geocoder::Calculations.extract_coordinates(coords)
+  end
+
+  def test_extract_nan_coordinates
+    result = Geocoder::Calculations.extract_coordinates([ nil, nil ])
+    assert_nan_coordinates?(result)
+
+    result = Geocoder::Calculations.extract_coordinates(nil)
+    assert_nan_coordinates?(result)
+
+    result = Geocoder::Calculations.extract_coordinates('')
+    assert_nan_coordinates?(result)
+
+    result = Geocoder::Calculations.extract_coordinates([ 'nix' ])
+    assert_nan_coordinates?(result)
+
+    o = Object.new
+    result = Geocoder::Calculations.extract_coordinates(o)
+    assert_nan_coordinates?(result)
+  end
+
+  def test_coordinates_present
+    assert Geocoder::Calculations.coordinates_present?(3.23)
+    assert !Geocoder::Calculations.coordinates_present?(nil)
+    assert !Geocoder::Calculations.coordinates_present?(Geocoder::Calculations::NAN)
+    assert !Geocoder::Calculations.coordinates_present?(3.23, nil)
+  end
+
+  private # ------------------------------------------------------------------
+
+  def assert_nan_coordinates?(value)
+    assert value.is_a?(Array) &&
+      value.size == 2 &&
+      value[0].nan? &&
+      value[1].nan?,
+      "Expected value to be [NaN, NaN] but was #{value}"
+  end
+
+  def test_endpoint
+    # test 5 time with random coordinates and headings
+    [0..5].each do |i|
+      rheading = [*0..359].sample
+      rdistance = [*0..100].sample
+      startpoint = [45.0906, 7.6596]
+      endpoint = Geocoder::Calculations.endpoint(startpoint, rheading, rdistance)
+      assert_in_delta rdistance, 
+        Geocoder::Calculations.distance_between(startpoint, endpoint, :method => :spherical), 1E-5
+      assert_in_delta rheading, 
+        Geocoder::Calculations.bearing_between(startpoint, endpoint, :method => :spherical), 1E-2
+    end
+  end
+end

data/test/unit/configuration_test.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class ConfigurationTest < GeocoderTestCase
+  def setup
+    Geocoder::Configuration.set_defaults
+  end
+
+  def test_exception_raised_on_bad_lookup_config
+    Geocoder.configure(:lookup => :stoopid)
+    assert_raises Geocoder::ConfigurationError do
+      Geocoder.search "something dumb"
+    end
+  end
+
+  def test_setting_with_class_method
+    Geocoder::Configuration.units = :test
+    assert_equal :test, Geocoder.config.units
+  end
+
+  def test_setting_with_configure_method
+    Geocoder.configure(:units => :test)
+    assert_equal :test, Geocoder.config.units
+  end
+
+  def test_config_for_lookup
+    Geocoder.configure(
+      :timeout => 5,
+      :api_key => "aaa",
+      :google => {
+        :timeout => 2
+      }
+    )
+    assert_equal 2, Geocoder.config_for_lookup(:google).timeout
+    assert_equal "aaa", Geocoder.config_for_lookup(:google).api_key
+  end
+
+  def test_configuration_chain
+    v = PlaceReverseGeocoded.new(*reverse_geocoded_object_params(:msg))
+    v.latitude  = 0
+    v.longitude = 0
+
+    # method option > global configuration
+    Geocoder.configure(:units => :km)
+    assert_equal 69, v.distance_to([0,1], :mi).round
+
+    # per-model configuration > global configuration
+    PlaceReverseGeocoded.reverse_geocoded_by :latitude, :longitude, method: :spherical, units: :mi
+    assert_equal 69, v.distance_to([0,1]).round
+
+    # method option > per-model configuration
+    assert_equal 111, v.distance_to([0,1], :km).round
+  end
+end

data/test/unit/error_handling_test.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class ErrorHandlingTest < GeocoderTestCase
+
+  def teardown
+    Geocoder.configure(:always_raise => [])
+  end
+
+  def test_does_not_choke_on_timeout
+    silence_warnings do
+      Geocoder::Lookup.all_services_except_test.each do |l|
+        Geocoder.configure(:lookup => l)
+        set_api_key!(l)
+        assert_nothing_raised { Geocoder.search("timeout") }
+      end
+    end
+  end
+
+  def test_always_raise_timeout_error
+    Geocoder.configure(:always_raise => [TimeoutError])
+    Geocoder::Lookup.all_services_except_test.each do |l|
+      next if l == :maxmind_local || l == :geoip2 # local, does not use cache
+      lookup = Geocoder::Lookup.get(l)
+      set_api_key!(l)
+      assert_raises TimeoutError do
+        lookup.send(:results, Geocoder::Query.new("timeout"))
+      end
+    end
+  end
+
+  def test_always_raise_socket_error
+    Geocoder.configure(:always_raise => [SocketError])
+    Geocoder::Lookup.all_services_except_test.each do |l|
+      next if l == :maxmind_local || l == :geoip2 # local, does not use cache
+      lookup = Geocoder::Lookup.get(l)
+      set_api_key!(l)
+      assert_raises SocketError do
+        lookup.send(:results, Geocoder::Query.new("socket_error"))
+      end
+    end
+  end
+
+  def test_always_raise_connection_refused_error
+    Geocoder.configure(:always_raise => [Errno::ECONNREFUSED])
+    Geocoder::Lookup.all_services_except_test.each do |l|
+      next if l == :maxmind_local || l == :geoip2 # local, does not use cache
+      lookup = Geocoder::Lookup.get(l)
+      set_api_key!(l)
+      assert_raises Errno::ECONNREFUSED do
+        lookup.send(:results, Geocoder::Query.new("connection_refused"))
+      end
+    end
+  end
+end

data/test/unit/geocoder_test.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+$: << File.join(File.dirname(__FILE__), "..")
+require 'test_helper'
+
+class GeocoderTest < GeocoderTestCase
+
+  def test_distance_to_returns_float
+    v = Place.new(*geocoded_object_params(:msg))
+    v.latitude, v.longitude = [40.750354, -73.993371]
+    assert (v.distance_to([30, -94])).is_a?(Float)
+  end
+
+  def test_coordinates_method_returns_array
+    assert Geocoder.coordinates("Madison Square Garden, New York, NY").is_a?(Array)
+  end
+
+  def test_address_method_returns_string
+    assert Geocoder.address([40.750354, -73.993371]).is_a?(String)
+  end
+
+  def test_geographic_center_doesnt_overwrite_argument_value
+    # test for the presence of a bug that was introduced in version 0.9.11
+    orig_points = [[52,8], [46,9], [42,5]]
+    points = orig_points.clone
+    Geocoder::Calculations.geographic_center(points)
+    assert_equal orig_points, points
+  end
+
+  def test_geocode_assigns_and_returns_coordinates
+    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 = PlaceWithCustomResultsHandling.new("Nowhere", "no results")
+    v.geocode
+    assert_equal "NOT FOUND", v.coords_string
+  end
+
+  def test_reverse_geocode_assigns_and_returns_address
+    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 = PlaceWithForwardAndReverseGeocoding.new("Exxon")
+    g.address = "404 New St, Middletown, CT"
+    g.geocode
+    assert_not_nil g.lat
+    assert_not_nil g.lon
+
+    assert_nil g.location
+    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