andre-geokit 1.1.0

data/test/test_base_geocoder.rb

@@ -0,0 +1,56 @@
+require 'test/unit'
+require 'net/http'
+require 'rubygems'
+require 'mocha'
+require 'lib/geokit'
+
+class MockSuccess < Net::HTTPSuccess #:nodoc: all
+  def initialize
+  end
+end
+
+class MockFailure < Net::HTTPServiceUnavailable #:nodoc: all
+  def initialize
+  end
+end
+
+# Base class for testing geocoders.
+class BaseGeocoderTest < Test::Unit::TestCase #:nodoc: all
+
+  # Defines common test fixtures.
+  def setup
+    @address = 'San Francisco, CA'    
+    @full_address = '100 Spear St, San Francisco, CA, 94105-1522, US'   
+    @full_address_short_zip = '100 Spear St, San Francisco, CA, 94105, US' 
+    
+    @success = Geokit::GeoLoc.new({:city=>"SAN FRANCISCO", :state=>"CA", :country_code=>"US", :lat=>37.7742, :lng=>-122.417068})
+    @success.success = true    
+  end  
+  
+  def test_timeout_call_web_service
+    Geokit::Geocoders::Geocoder.class_eval do
+      def self.do_get(url)
+        sleep(2)
+      end
+    end
+    url = "http://www.anything.com"
+    Geokit::Geocoders::timeout = 1
+    assert_nil Geokit::Geocoders::Geocoder.call_geocoder_service(url)    
+  end
+  
+  def test_successful_call_web_service
+    url = "http://www.anything.com"
+    Geokit::Geocoders::Geocoder.expects(:do_get).with(url).returns("SUCCESS")
+    assert_equal "SUCCESS", Geokit::Geocoders::Geocoder.call_geocoder_service(url)
+  end
+  
+  def test_find_geocoder_methods
+    public_methods = Geokit::Geocoders::Geocoder.public_methods
+    assert public_methods.include?("yahoo_geocoder")
+    assert public_methods.include?("google_geocoder")
+    assert public_methods.include?("ca_geocoder")
+    assert public_methods.include?("us_geocoder")
+    assert public_methods.include?("multi_geocoder")
+    assert public_methods.include?("ip_geocoder")
+  end
+end

data/test/test_bounds.rb

@@ -0,0 +1,74 @@
+require 'test/unit'
+require 'lib/geokit'
+
+class BoundsTest < Test::Unit::TestCase #:nodoc: all
+  
+  def setup
+    # This is the area in Texas
+    @sw = Geokit::LatLng.new(32.91663,-96.982841)
+    @ne = Geokit::LatLng.new(32.96302,-96.919495)
+    @bounds=Geokit::Bounds.new(@sw,@ne) 
+    @loc_a=Geokit::LatLng.new(32.918593,-96.958444) # inside bounds    
+    @loc_b=Geokit::LatLng.new(32.914144,-96.958444) # outside bouds
+    
+    # this is a cross-meridan area
+    @cross_meridian=Geokit::Bounds.normalize([30,170],[40,-170])
+    @inside_cm=Geokit::LatLng.new(35,175)
+    @inside_cm_2=Geokit::LatLng.new(35,-175)
+    @east_of_cm=Geokit::LatLng.new(35,-165)
+    @west_of_cm=Geokit::LatLng.new(35,165)
+
+  end  
+
+  def test_equality
+    assert_equal Geokit::Bounds.new(@sw,@ne), Geokit::Bounds.new(@sw,@ne)
+  end  
+  
+  def test_normalize
+    res=Geokit::Bounds.normalize(@sw,@ne)
+    assert_equal res,Geokit::Bounds.new(@sw,@ne)     
+    res=Geokit::Bounds.normalize([@sw,@ne])
+    assert_equal res,Geokit::Bounds.new(@sw,@ne)
+    res=Geokit::Bounds.normalize([@sw.lat,@sw.lng],[@ne.lat,@ne.lng])
+    assert_equal res,Geokit::Bounds.new(@sw,@ne)
+    res=Geokit::Bounds.normalize([[@sw.lat,@sw.lng],[@ne.lat,@ne.lng]])
+    assert_equal res,Geokit::Bounds.new(@sw,@ne)
+  end
+  
+  def test_point_inside_bounds
+    assert @bounds.contains?(@loc_a)
+  end
+
+  def test_point_outside_bounds
+    assert !@bounds.contains?(@loc_b) 
+  end  
+
+  def test_point_inside_bounds_cross_meridian
+    assert @cross_meridian.contains?(@inside_cm)
+    assert @cross_meridian.contains?(@inside_cm_2)
+  end
+
+  def test_point_outside_bounds_cross_meridian
+    assert !@cross_meridian.contains?(@east_of_cm)
+    assert !@cross_meridian.contains?(@west_of_cm)
+  end    
+  
+  def test_center
+    assert_in_delta 32.939828,@bounds.center.lat,0.00005
+    assert_in_delta -96.9511763,@bounds.center.lng,0.00005
+  end
+
+  def test_center_cross_meridian
+    assert_in_delta 35.41160, @cross_meridian.center.lat,0.00005
+    assert_in_delta 179.38112, @cross_meridian.center.lng,0.00005
+  end  
+  
+  def test_creation_from_circle
+    bounds=Geokit::Bounds.from_point_and_radius([32.939829, -96.951176],2.5)
+    inside=Geokit::LatLng.new 32.9695270000,-96.9901590000
+    outside=Geokit::LatLng.new 32.8951550000,-96.9584440000
+    assert bounds.contains?(inside)
+    assert !bounds.contains?(outside)
+  end
+  
+end

data/test/test_ca_geocoder.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), 'test_base_geocoder')
+
+Geokit::Geocoders::geocoder_ca = "SOMEKEYVALUE"
+
+class CaGeocoderTest < BaseGeocoderTest #:nodoc: all
+  
+  CA_SUCCESS=<<-EOF
+  <?xml version="1.0" encoding="UTF-8" ?>
+  <geodata><latt>49.243086</latt><longt>-123.153684</longt></geodata>  
+  EOF
+  
+  def setup
+    @ca_full_hash = {:street_address=>"2105 West 32nd Avenue",:city=>"Vancouver", :state=>"BC"}
+    @ca_full_loc = Geokit::GeoLoc.new(@ca_full_hash)
+  end  
+  
+  def test_geocoder_with_geo_loc_with_account
+    response = MockSuccess.new
+    response.expects(:body).returns(CA_SUCCESS)
+    url = "http://geocoder.ca/?stno=2105&addresst=West+32nd+Avenue&city=Vancouver&prov=BC&auth=SOMEKEYVALUE&geoit=xml"
+    Geokit::Geocoders::CaGeocoder.expects(:call_geocoder_service).with(url).returns(response)
+    verify(Geokit::Geocoders::CaGeocoder.geocode(@ca_full_loc))    
+  end
+  
+  def test_service_unavailable
+    response = MockFailure.new
+    #Net::HTTP.expects(:get_response).with(URI.parse("http://geocoder.ca/?stno=2105&addresst=West+32nd+Avenue&city=Vancouver&prov=BC&auth=SOMEKEYVALUE&geoit=xml")).returns(response)  
+    url = "http://geocoder.ca/?stno=2105&addresst=West+32nd+Avenue&city=Vancouver&prov=BC&auth=SOMEKEYVALUE&geoit=xml" 
+    Geokit::Geocoders::CaGeocoder.expects(:call_geocoder_service).with(url).returns(response)
+    assert !Geokit::Geocoders::CaGeocoder.geocode(@ca_full_loc).success   
+  end  
+  
+  private
+  
+  def verify(location)
+    assert_equal "BC", location.state
+    assert_equal "Vancouver", location.city 
+    assert_equal "49.243086,-123.153684", location.ll 
+    assert !location.is_us? 
+  end
+end

data/test/test_geoloc.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require 'lib/geokit'
+
+class GeoLocTest < Test::Unit::TestCase #:nodoc: all
+  
+  def setup
+    @loc = Geokit::GeoLoc.new
+  end
+  
+  def test_is_us
+    assert !@loc.is_us?
+    @loc.country_code = 'US'
+    assert @loc.is_us?
+  end
+  
+  def test_street_number
+    @loc.street_address = '123 Spear St.'
+    assert_equal '123', @loc.street_number
+  end
+  
+  def test_street_name
+    @loc.street_address = '123 Spear St.'
+    assert_equal 'Spear St.', @loc.street_name
+  end
+  
+  def test_city
+    @loc.city = "san francisco"
+    assert_equal 'San Francisco', @loc.city
+  end
+  
+  def test_full_address
+    @loc.city = 'San Francisco'
+    @loc.state = 'CA'
+    @loc.zip = '94105'
+    @loc.country_code = 'US'
+    assert_equal 'San Francisco, CA, 94105, US', @loc.full_address
+    @loc.full_address = 'Irving, TX, 75063, US'
+    assert_equal 'Irving, TX, 75063, US', @loc.full_address
+  end
+  
+  def test_hash
+    @loc.city = 'San Francisco'
+    @loc.state = 'CA'
+    @loc.zip = '94105'
+    @loc.country_code = 'US'
+    @another = Geokit::GeoLoc.new @loc.to_hash    
+    assert_equal @loc, @another
+  end
+end

data/test/test_google_geocoder.rb

@@ -0,0 +1,88 @@
+require File.join(File.dirname(__FILE__), 'test_base_geocoder')
+
+Geokit::Geocoders::google = 'Google'
+
+class GoogleGeocoderTest < BaseGeocoderTest #:nodoc: all
+  
+  GOOGLE_FULL=<<-EOF.strip
+  <?xml version="1.0" encoding="UTF-8"?><kml xmlns="http://earth.google.com/kml/2.0"><Response><name>100 spear st, san francisco, ca</name><Status><code>200</code><request>geocode</request></Status><Placemark><address>100 Spear St, San Francisco, CA 94105, USA</address><AddressDetails Accuracy="8" xmlns="urn:oasis:names:tc:ciq:xsdschema:xAL:2.0"><Country><CountryNameCode>US</CountryNameCode><AdministrativeArea><AdministrativeAreaName>CA</AdministrativeAreaName><SubAdministrativeArea><SubAdministrativeAreaName>San Francisco</SubAdministrativeAreaName><Locality><LocalityName>San Francisco</LocalityName><Thoroughfare><ThoroughfareName>100 Spear St</ThoroughfareName></Thoroughfare><PostalCode><PostalCodeNumber>94105</PostalCodeNumber></PostalCode></Locality></SubAdministrativeArea></AdministrativeArea></Country></AddressDetails><Point><coordinates>-122.393985,37.792501,0</coordinates></Point></Placemark></Response></kml>
+  EOF
+
+  GOOGLE_CITY=<<-EOF.strip
+  <?xml version="1.0" encoding="UTF-8"?><kml xmlns="http://earth.google.com/kml/2.0"><Response><name>San Francisco</name><Status><code>200</code><request>geocode</request></Status><Placemark><address>San Francisco, CA, USA</address><AddressDetails Accuracy="4" xmlns="urn:oasis:names:tc:ciq:xsdschema:xAL:2.0"><Country><CountryNameCode>US</CountryNameCode><AdministrativeArea><AdministrativeAreaName>CA</AdministrativeAreaName><Locality><LocalityName>San Francisco</LocalityName></Locality></AdministrativeArea></Country></AddressDetails><Point><coordinates>-122.418333,37.775000,0</coordinates></Point></Placemark></Response></kml>
+  EOF
+  
+  def setup
+    super
+    @google_full_hash = {:street_address=>"100 Spear St", :city=>"San Francisco", :state=>"CA", :zip=>"94105", :country_code=>"US"}
+    @google_city_hash = {:city=>"San Francisco", :state=>"CA"}
+
+    @google_full_loc = Geokit::GeoLoc.new(@google_full_hash)
+    @google_city_loc = Geokit::GeoLoc.new(@google_city_hash)
+  end  
+
+  def test_google_full_address
+    response = MockSuccess.new
+    response.expects(:body).returns(GOOGLE_FULL)
+    url = "http://maps.google.com/maps/geo?q=#{Geokit::Inflector.url_escape(@address)}&output=xml&key=Google&oe=utf-8"
+    Geokit::Geocoders::GoogleGeocoder.expects(:call_geocoder_service).with(url).returns(response)
+    res=Geokit::Geocoders::GoogleGeocoder.geocode(@address)
+    assert_equal "CA", res.state
+    assert_equal "San Francisco", res.city 
+    assert_equal "37.792501,-122.393985", res.ll # slightly dif from yahoo
+    assert res.is_us?
+    assert_equal "100 Spear St, San Francisco, CA 94105, USA", res.full_address #slightly different from yahoo
+    assert_equal "google", res.provider
+  end
+  
+  def test_google_full_address_with_geo_loc
+    response = MockSuccess.new
+    response.expects(:body).returns(GOOGLE_FULL)
+    url = "http://maps.google.com/maps/geo?q=#{Geokit::Inflector.url_escape(@full_address_short_zip)}&output=xml&key=Google&oe=utf-8"
+    Geokit::Geocoders::GoogleGeocoder.expects(:call_geocoder_service).with(url).returns(response)
+    res=Geokit::Geocoders::GoogleGeocoder.geocode(@google_full_loc)
+    assert_equal "CA", res.state
+    assert_equal "San Francisco", res.city 
+    assert_equal "37.792501,-122.393985", res.ll # slightly dif from yahoo
+    assert res.is_us?
+    assert_equal "100 Spear St, San Francisco, CA 94105, USA", res.full_address #slightly different from yahoo
+    assert_equal "google", res.provider
+  end  
+
+  def test_google_city
+    response = MockSuccess.new
+    response.expects(:body).returns(GOOGLE_CITY)
+    url = "http://maps.google.com/maps/geo?q=#{Geokit::Inflector.url_escape(@address)}&output=xml&key=Google&oe=utf-8"
+    Geokit::Geocoders::GoogleGeocoder.expects(:call_geocoder_service).with(url).returns(response)
+    res=Geokit::Geocoders::GoogleGeocoder.geocode(@address)
+    assert_equal "CA", res.state
+    assert_equal "San Francisco", res.city
+    assert_equal "37.775,-122.418333", res.ll
+    assert res.is_us?
+    assert_equal "San Francisco, CA, USA", res.full_address
+    assert_nil res.street_address
+    assert_equal "google", res.provider
+  end  
+  
+  def test_google_city_with_geo_loc
+    response = MockSuccess.new
+    response.expects(:body).returns(GOOGLE_CITY)
+    url = "http://maps.google.com/maps/geo?q=#{Geokit::Inflector.url_escape(@address)}&output=xml&key=Google&oe=utf-8"
+    Geokit::Geocoders::GoogleGeocoder.expects(:call_geocoder_service).with(url).returns(response)
+    res=Geokit::Geocoders::GoogleGeocoder.geocode(@google_city_loc)
+    assert_equal "CA", res.state
+    assert_equal "San Francisco", res.city
+    assert_equal "37.775,-122.418333", res.ll
+    assert res.is_us?
+    assert_equal "San Francisco, CA, USA", res.full_address
+    assert_nil res.street_address
+    assert_equal "google", res.provider
+  end  
+  
+  def test_service_unavailable
+    response = MockFailure.new
+    url = "http://maps.google.com/maps/geo?q=#{Geokit::Inflector.url_escape(@address)}&output=xml&key=Google&oe=utf-8"
+    Geokit::Geocoders::GoogleGeocoder.expects(:call_geocoder_service).with(url).returns(response)
+    assert !Geokit::Geocoders::GoogleGeocoder.geocode(@google_city_loc).success
+  end 
+end

data/test/test_latlng.rb

@@ -0,0 +1,111 @@
+require 'test/unit'
+require 'lib/geokit'
+
+class LatLngTest < Test::Unit::TestCase #:nodoc: all
+  
+  def setup
+    @loc_a = Geokit::LatLng.new(32.918593,-96.958444)
+    @loc_e = Geokit::LatLng.new(32.969527,-96.990159)
+    @point = Geokit::LatLng.new(@loc_a.lat, @loc_a.lng)
+  end
+  
+  def test_distance_between_same_using_defaults
+    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a)
+    assert_equal 0, @loc_a.distance_to(@loc_a)
+  end
+  
+  def test_distance_between_same_with_miles_and_flat
+    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, :units => :miles, :formula => :flat)
+    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :miles, :formula => :flat)
+  end
+
+  def test_distance_between_same_with_kms_and_flat
+    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, :units => :kms, :formula => :flat)
+    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :kms, :formula => :flat)
+  end
+  
+  def test_distance_between_same_with_miles_and_sphere
+    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, :units => :miles, :formula => :sphere)
+    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :miles, :formula => :sphere)
+  end
+  
+  def test_distance_between_same_with_kms_and_sphere
+    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, :units => :kms, :formula => :sphere)
+    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :kms, :formula => :sphere)
+  end
+  
+  def test_distance_between_diff_using_defaults
+    assert_in_delta 3.97, Geokit::LatLng.distance_between(@loc_a, @loc_e), 0.01
+    assert_in_delta 3.97, @loc_a.distance_to(@loc_e), 0.01
+  end
+  
+  def test_distance_between_diff_with_miles_and_flat
+    assert_in_delta 3.97, Geokit::LatLng.distance_between(@loc_a, @loc_e, :units => :miles, :formula => :flat), 0.2
+    assert_in_delta 3.97, @loc_a.distance_to(@loc_e, :units => :miles, :formula => :flat), 0.2
+  end
+
+  def test_distance_between_diff_with_kms_and_flat
+    assert_in_delta 6.39, Geokit::LatLng.distance_between(@loc_a, @loc_e, :units => :kms, :formula => :flat), 0.4
+    assert_in_delta 6.39, @loc_a.distance_to(@loc_e, :units => :kms, :formula => :flat), 0.4
+  end
+  
+  def test_distance_between_diff_with_miles_and_sphere
+    assert_in_delta 3.97, Geokit::LatLng.distance_between(@loc_a, @loc_e, :units => :miles, :formula => :sphere), 0.01
+    assert_in_delta 3.97, @loc_a.distance_to(@loc_e, :units => :miles, :formula => :sphere), 0.01
+  end
+  
+  def test_distance_between_diff_with_kms_and_sphere
+    assert_in_delta 6.39, Geokit::LatLng.distance_between(@loc_a, @loc_e, :units => :kms, :formula => :sphere), 0.01
+    assert_in_delta 6.39, @loc_a.distance_to(@loc_e, :units => :kms, :formula => :sphere), 0.01
+  end
+  
+  def test_manually_mixed_in
+    assert_equal 0, Geokit::LatLng.distance_between(@point, @point)
+    assert_equal 0, @point.distance_to(@point)
+    assert_equal 0, @point.distance_to(@loc_a)
+    assert_in_delta 3.97, @point.distance_to(@loc_e, :units => :miles, :formula => :flat), 0.2
+    assert_in_delta 6.39, @point.distance_to(@loc_e, :units => :kms, :formula => :flat), 0.4
+  end
+  
+  def test_heading_between
+    assert_in_delta 332, Geokit::LatLng.heading_between(@loc_a,@loc_e), 0.5
+  end
+
+  def test_heading_to
+    assert_in_delta 332, @loc_a.heading_to(@loc_e), 0.5
+  end  
+  
+  def test_class_endpoint
+    endpoint=Geokit::LatLng.endpoint(@loc_a, 332, 3.97)
+    assert_in_delta @loc_e.lat, endpoint.lat, 0.0005
+    assert_in_delta @loc_e.lng, endpoint.lng, 0.0005
+  end
+
+  def test_instance_endpoint
+    endpoint=@loc_a.endpoint(332, 3.97)
+    assert_in_delta @loc_e.lat, endpoint.lat, 0.0005
+    assert_in_delta @loc_e.lng, endpoint.lng, 0.0005
+  end  
+  
+  def test_midpoint
+    midpoint=@loc_a.midpoint_to(@loc_e)
+    assert_in_delta 32.944061, midpoint.lat, 0.0005
+    assert_in_delta(-96.974296, midpoint.lng, 0.0005)
+  end  
+  
+  def test_normalize
+    lat=37.7690
+    lng=-122.443
+    res=Geokit::LatLng.normalize(lat,lng)
+    assert_equal res,Geokit::LatLng.new(lat,lng) 
+    res=Geokit::LatLng.normalize("#{lat}, #{lng}")
+    assert_equal res,Geokit::LatLng.new(lat,lng) 
+    res=Geokit::LatLng.normalize("#{lat} #{lng}")
+    assert_equal res,Geokit::LatLng.new(lat,lng)
+    res=Geokit::LatLng.normalize("#{lat.to_i} #{lng.to_i}")
+    assert_equal res,Geokit::LatLng.new(lat.to_i,lng.to_i)    
+    res=Geokit::LatLng.normalize([lat,lng])
+    assert_equal res,Geokit::LatLng.new(lat,lng)
+  end
+    
+end

data/test/test_multi_geocoder.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), 'test_base_geocoder')
+
+Geokit::Geocoders::provider_order=[:google,:yahoo,:us]
+
+class MultiGeocoderTest < BaseGeocoderTest #:nodoc: all
+  
+  def setup
+    super
+    @failure = Geokit::GeoLoc.new
+  end
+  
+  def test_successful_first
+    Geokit::Geocoders::GoogleGeocoder.expects(:geocode).with(@address).returns(@success)
+    assert_equal @success, Geokit::Geocoders::MultiGeocoder.geocode(@address)
+  end
+  
+  def test_failover
+    Geokit::Geocoders::GoogleGeocoder.expects(:geocode).with(@address).returns(@failure)
+    Geokit::Geocoders::YahooGeocoder.expects(:geocode).with(@address).returns(@success)
+    assert_equal @success, Geokit::Geocoders::MultiGeocoder.geocode(@address)    
+  end
+  
+  def test_double_failover
+    Geokit::Geocoders::GoogleGeocoder.expects(:geocode).with(@address).returns(@failure)
+    Geokit::Geocoders::YahooGeocoder.expects(:geocode).with(@address).returns(@failure)
+    Geokit::Geocoders::UsGeocoder.expects(:geocode).with(@address).returns(@success)
+    assert_equal @success, Geokit::Geocoders::MultiGeocoder.geocode(@address)    
+  end
+  
+  def test_failure
+    Geokit::Geocoders::GoogleGeocoder.expects(:geocode).with(@address).returns(@failure)
+    Geokit::Geocoders::YahooGeocoder.expects(:geocode).with(@address).returns(@failure)
+    Geokit::Geocoders::UsGeocoder.expects(:geocode).with(@address).returns(@failure)
+    assert_equal @failure, Geokit::Geocoders::MultiGeocoder.geocode(@address)    
+  end
+
+  def test_invalid_provider
+    temp = Geokit::Geocoders::provider_order
+    Geokit::Geocoders.provider_order = [:bogus]
+    assert_equal @failure, Geokit::Geocoders::MultiGeocoder.geocode(@address)    
+    Geokit::Geocoders.provider_order = temp
+  end
+
+end