geocoder-sgonyea 1.1.6.1

data/test/active_record_test.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+require 'test_helper'
+
+class ActiveRecordTest < Test::Unit::TestCase
+
+  def test_exclude_condition_when_model_has_a_custom_primary_key
+    venue = VenuePlus.new(*venue_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( /#{VenuePlus.primary_key}/, conditions.join)
+  end
+
+end

data/test/cache_test.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+require 'test_helper'
+
+class CacheTest < Test::Unit::TestCase
+
+  def test_second_occurrence_of_request_is_cache_hit
+    Geocoder.configure(:cache => {})
+    Geocoder::Lookup.all_services_except_test.each do |l|
+      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
+end

data/test/calculations_test.rb

@@ -0,0 +1,195 @@
+# encoding: utf-8
+require 'test_helper'
+
+class CalculationsTest < Test::Unit::TestCase
+  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
+
+
+  # --- 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 = Landmark.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
+    dlon = radius / Geocoder::Calculations.latitude_degree_distance
+    dlat = radius / Geocoder::Calculations.longitude_degree_distance(center[0])
+    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)
+    dlon = radius / Geocoder::Calculations.latitude_degree_distance(:km)
+    dlat = radius / Geocoder::Calculations.longitude_degree_distance(center[0], :km)
+    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
+    dlon = radius / Geocoder::Calculations.latitude_degree_distance
+    dlat = radius / Geocoder::Calculations.longitude_degree_distance(center[0])
+    corners = [50.86, 6.77, 51.14, 7.23]
+    obj = Landmark.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
+
+
+  # --- 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 = Landmark.new(*landmark_params(:msg))
+    assert_equal 324, l.bearing_to([50,-85], :method => :spherical).round
+  end
+
+  def test_spherical_bearing_from
+    l = Landmark.new(*landmark_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 = Landmark.new(*landmark_params(:msg))
+    assert_equal l.bearing_from([50,-86.1]), l.bearing_to([50,-86.1]) - 180
+  end
+
+  def test_extract_coordinates
+    result = Geocoder::Calculations.extract_coordinates([ nil, nil ])
+    assert is_nan_coordinates?(result)
+
+    result = Geocoder::Calculations.extract_coordinates([ 1.0 / 3, 2.0 / 3 ])
+    assert_in_delta 1.0 / 3, result.first, 1E-5
+    assert_in_delta 2.0 / 3, result.last, 1E-5
+
+    result = Geocoder::Calculations.extract_coordinates(nil)
+    assert is_nan_coordinates?(result)
+
+    result = Geocoder::Calculations.extract_coordinates('')
+    assert is_nan_coordinates?(result)
+
+    result = Geocoder::Calculations.extract_coordinates([ 'nix' ])
+    assert is_nan_coordinates?(result)
+
+    o = Object.new
+    result = Geocoder::Calculations.extract_coordinates(o)
+    assert is_nan_coordinates?(result)
+
+    def o.to_coordinates
+      [ 1.0 / 3, 2.0 / 3 ]
+    end
+    result = Geocoder::Calculations.extract_coordinates(o)
+    assert_in_delta 1.0 / 3, result.first, 1E-5
+    assert_in_delta 2.0 / 3, result.last, 1E-5
+  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
+
+  def test_extract_coordinates
+    coords = [-23,47]
+    l = Landmark.new("Madagascar", coords[0], coords[1])
+    assert_equal coords, Geocoder::Calculations.extract_coordinates(l)
+    assert_equal coords, Geocoder::Calculations.extract_coordinates(coords)
+  end
+end

data/test/configuration_test.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+require 'test_helper'
+
+class ConfigurationTest < Test::Unit::TestCase
+  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_setting_with_block_syntax
+    orig = $VERBOSE; $VERBOSE = nil
+    Geocoder.configure do |config|
+      config.units = :test
+    end
+    assert_equal :test, Geocoder.config.units
+  ensure
+    $VERBOSE = orig
+  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_model_configuration
+    Landmark.reverse_geocoded_by :latitude, :longitude, :method => :spherical, :units => :km
+    assert_equal :km,        Landmark.geocoder_options[:units]
+    assert_equal :spherical, Landmark.geocoder_options[:method]
+
+    v = Landmark.new(*landmark_params(:msg))
+    v.latitude  = 0
+    v.longitude = 0
+    assert_equal 111, v.distance_to([0,1]).round
+    v.latitude  = 40.750354
+    v.longitude = -73.993371
+    assert_equal 136, v.bearing_from([50,-85]).round
+  end
+
+  def test_configuration_chain
+    v = Landmark.new(*landmark_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
+    Landmark.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/custom_block_test.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+require 'test_helper'
+
+class CustomBlockTest < Test::Unit::TestCase
+
+  def test_geocode_with_block_runs_block
+    e = Event.new(*venue_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 = Event.new(*venue_params(:msg))
+    e.geocode
+    assert_nil e.latitude
+    assert_nil e.longitude
+  end
+
+  def test_reverse_geocode_with_block_runs_block
+    e = Party.new(*landmark_params(:msg))
+    e.reverse_geocode
+    assert_equal "US", e.country
+  end
+
+  def test_reverse_geocode_with_block_doesnt_auto_assign_address
+    e = Party.new(*landmark_params(:msg))
+    e.reverse_geocode
+    assert_nil e.address
+  end
+end
+

data/test/error_handling_test.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require 'test_helper'
+
+class ErrorHandlingTest < Test::Unit::TestCase
+
+  def teardown
+    Geocoder.configure(:always_raise => [])
+  end
+
+  def test_does_not_choke_on_timeout
+    # keep test output clean: suppress timeout warning
+    orig = $VERBOSE; $VERBOSE = nil
+    Geocoder::Lookup.all_services_except_test.each do |l|
+      Geocoder.configure(:lookup => l)
+      set_api_key!(l)
+      assert_nothing_raised { Geocoder.search("timeout") }
+    end
+  ensure
+    $VERBOSE = orig
+  end
+
+  def test_always_raise_timeout_error
+    Geocoder.configure(:always_raise => [TimeoutError])
+    Geocoder::Lookup.all_services_except_test.each do |l|
+      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|
+      lookup = Geocoder::Lookup.get(l)
+      set_api_key!(l)
+      assert_raises SocketError do
+        lookup.send(:results, Geocoder::Query.new("socket_error"))
+      end
+    end
+  end
+end

data/test/fixtures/bing_invalid_key

@@ -0,0 +1 @@
+{"authenticationResultCode":"InvalidCredentials","brandLogoUri":"http:\\/\\/dev.virtualearth.net\\/Branding\\/logo_powered_by.png","copyright":"Copyright \xC2\xA9 2012 Microsoft and its suppliers. All rights reserved. This API cannot be accessed and the content and any results may not be used, reproduced or transmitted in any manner without express written permission from Microsoft Corporation.","errorDetails":["Access was denied. You may have entered your credentials incorrectly, or you might not have access to the requested resource or operation."],"resourceSets":[],"statusCode":401,"statusDescription":"Unauthorized","traceId":"5c539f6e70c44b2e858741b6c932318e|EWRM001670|02.00.83.1900|"}

data/test/fixtures/bing_madison_square_garden

@@ -0,0 +1,40 @@
+{
+   "authenticationResultCode":"ValidCredentials",
+   "brandLogoUri":"http:\/\/dev.virtualearth.net\/Branding\/logo_powered_by.png",
+   "copyright":"Copyright © 2011 Microsoft and its suppliers. All rights reserved. This API cannot be accessed and the content and any results may not be used, reproduced or transmitted in any manner without express written permission from Microsoft Corporation.",
+   "resourceSets":[
+      {
+         "estimatedTotal":1,
+         "resources":[
+            {
+               "__type":"Location:http:\/\/schemas.microsoft.com\/search\/local\/ws\/rest\/v1",
+               "bbox":[
+                  40.744944289326668,
+                  -74.002353921532631,
+                  40.755675807595253,
+                  -73.983625397086143
+               ],
+               "name":"Madison Square Garden, NY",
+               "point":{
+                  "type":"Point",
+                  "coordinates":[
+                     40.75031,
+                     -73.99299
+                  ]
+               },
+               "address":{
+                  "adminDistrict":"NY",
+                  "countryRegion":"United States",
+                  "formattedAddress":"Madison Square Garden, NY",
+                  "locality":"New York"
+               },
+               "confidence":"High",
+               "entityType":"Stadium"
+            }
+         ]
+      }
+   ],
+   "statusCode":200,
+   "statusDescription":"OK",
+   "traceId":"55094ee53c8d45e789794014666328cd|CH1M001466|02.00.82.2800|CH1MSNVM001396, CH1MSNVM001370, CH1MSNVM001397"
+}

data/test/fixtures/bing_no_results

@@ -0,0 +1,16 @@
+{
+   "authenticationResultCode":"ValidCredentials",
+   "brandLogoUri":"http:\/\/dev.virtualearth.net\/Branding\/logo_powered_by.png",
+   "copyright":"Copyright © 2011 Microsoft and its suppliers. All rights reserved. This API cannot be accessed and the content and any results may not be used, reproduced or transmitted in any manner without express written permission from Microsoft Corporation.",
+   "resourceSets":[
+      {
+         "estimatedTotal":0,
+         "resources":[
+
+         ]
+      }
+   ],
+   "statusCode":200,
+   "statusDescription":"OK",
+   "traceId":"907b76a307bc49129a489de3d4c992ea|CH1M001463|02.00.82.2800|CH1MSNVM001383, CH1MSNVM001358, CH1MSNVM001397"
+}