rails-geocoder 0.9.8 → 0.9.9

data/test/fixtures/google_madison_square_garden.json

@@ -0,0 +1,57 @@
+{
+  "status": "OK",
+  "results": [ {
+    "types": [ "street_address" ],
+    "formatted_address": "4 Penn Plaza, New York, NY 10001, USA",
+    "address_components": [ {
+      "long_name": "4",
+      "short_name": "4",
+      "types": [ "street_number" ]
+    }, {
+      "long_name": "Penn Plaza",
+      "short_name": "Penn Plaza",
+      "types": [ "route" ]
+    }, {
+      "long_name": "Manhattan",
+      "short_name": "Manhattan",
+      "types": [ "sublocality", "political" ]
+    }, {
+      "long_name": "New York",
+      "short_name": "New York",
+      "types": [ "locality", "political" ]
+    }, {
+      "long_name": "New York",
+      "short_name": "New York",
+      "types": [ "administrative_area_level_2", "political" ]
+    }, {
+      "long_name": "New York",
+      "short_name": "NY",
+      "types": [ "administrative_area_level_1", "political" ]
+    }, {
+      "long_name": "United States",
+      "short_name": "US",
+      "types": [ "country", "political" ]
+    }, {
+      "long_name": "10001",
+      "short_name": "10001",
+      "types": [ "postal_code" ]
+    } ],
+    "geometry": {
+      "location": {
+        "lat": 40.7503540,
+        "lng": -73.9933710
+      },
+      "location_type": "ROOFTOP",
+      "viewport": {
+        "southwest": {
+          "lat": 40.7473324,
+          "lng": -73.9965316
+        },
+        "northeast": {
+          "lat": 40.7536276,
+          "lng": -73.9902364
+        }
+      }
+    }
+  } ]
+}

data/test/fixtures/google_no_results.json

@@ -0,0 +1,4 @@
+{
+  "status": "ZERO_RESULTS",
+  "results": [ ]
+}

data/test/fixtures/yahoo_garbage.json

@@ -0,0 +1,50 @@
+{
+  "ResultSet":{
+    "version":"1.0",
+    "Error":0,
+    "ErrorMessage":"No error",
+    "Locale":"us_US",
+    "Quality":87,
+    "Found":1,
+    "Results":[{
+      "quality":9,
+      "latitude":"55.008390",
+      "longitude":"-5.822485",
+      "offsetlat":"54.314072",
+      "offsetlon":"-2.230010",
+      "radius":1145100,
+      "boundingbox":{
+        "north":"60.854691",
+        "south":"49.162090",
+        "east":"1.768960",
+        "west":"-13.413930"
+      },
+      "name":"",
+      "line1":"",
+      "line2":"",
+      "line3":"",
+      "line4":"United Kingdom",
+      "cross":"",
+      "house":"",
+      "street":"",
+      "xstreet":"",
+      "unittype":"",
+      "unit":"",
+      "postal":"",
+      "neighborhood":"",
+      "city":"",
+      "county":"",
+      "state":"",
+      "country":"United Kingdom",
+      "countrycode":"GB",
+      "statecode":"",
+      "countycode":"",
+      "timezone":"Europe/London",
+      "areacode":"",
+      "uzip":"",
+      "hash":"",
+      "woeid":23424975,
+      "woetype":12
+    }]
+  }
+}

data/test/fixtures/yahoo_madison_square_garden.json

@@ -0,0 +1,46 @@
+{
+  "ResultSet":{
+    "version":"1.0",
+    "Error":0,
+    "ErrorMessage":"No error",
+    "Locale":"us_US",
+    "Quality":90,
+    "Found":1,
+    "Results":[{
+      "quality":90,
+      "latitude":"40.750381",
+      "longitude":"-73.993988",
+      "offsetlat":"40.750381",
+      "offsetlon":"-73.993988",
+      "radius":100,
+      "name":"Madison Square Garden",
+      "line1":"Madison Square Garden",
+      "line2":"New York, NY  10001",
+      "line3":"",
+      "line4":"United States",
+      "house":"",
+      "street":"",
+      "xstreet":"",
+      "unittype":"",
+      "unit":"",
+      "postal":"10001",
+      "neighborhood":"",
+      "city":"New York",
+      "county":"New York County",
+      "state":"New York",
+      "country":"United States",
+      "countrycode":"US",
+      "statecode":"NY",
+      "countycode":"",
+      "uzip":"10001",
+      "hash":"",
+      "woeid":23617041,
+      "woetype":20,
+      "cross":"",
+      "timezone":"America/New_York",
+      "neighborhood":"Garment District|Midtown|Midtown West|Manhattan",
+      "areacode":"212",
+      "boundingbox":{"north":"40.750832","south":"40.749931","east":"-73.993393","west":"-73.994591"}
+    }]
+  }
+}

data/test/fixtures/yahoo_no_results.json

@@ -0,0 +1,10 @@
+{
+  "ResultSet":{
+    "version":"1.0",
+    "Error":0,
+    "ErrorMessage":"No error",
+    "Locale":"us_US",
+    "Quality":10,
+    "Found":0
+  }
+}

data/test/geocoder_test.rb

@@ -2,18 +2,17 @@ require 'test_helper'
 
 class GeocoderTest < Test::Unit::TestCase
 
-  def test_fetch_coordinates
-    v = Venue.new(*venue_params(:msg))
-    assert_equal [40.750354, -73.993371], v.fetch_coordinates
-    assert_equal [40.750354, -73.993371], [v.latitude, v.longitude]
+  def setup
+    Geocoder::Configuration.lookup = :google
   end
 
-  # sanity check
+
+  # --- sanity checks ---
+
   def test_distance_between
     assert_equal 69, Geocoder::Calculations.distance_between(0,0, 0,1).round
   end
 
-  # sanity check
   def test_geographic_center
     assert_equal [0.0, 0.5],
       Geocoder::Calculations.geographic_center([[0,0], [0,1]])
@@ -21,16 +20,190 @@ class GeocoderTest < Test::Unit::TestCase
       Geocoder::Calculations.geographic_center([[0,0], [0,1], [0,2]])
   end
 
-  def test_exception_raised_for_unconfigured_geocoding
-    l = Landmark.new("Mount Rushmore", 43.88, -103.46)
-    assert_raises Geocoder::ConfigurationError do
-      l.fetch_coordinates
+  def test_does_not_choke_on_nil_address
+    v = Venue.new("Venue", nil)
+    assert_nothing_raised do
+      v.geocode
     end
   end
 
+  def test_distance_to_returns_float
+    v = Venue.new(*venue_params(:msg))
+    v.latitude, v.longitude = [40.750354, -73.993371]
+    assert (d = v.distance_to(30, -94)).is_a?(Float)
+  end
+
+  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
+
+
+  # --- general ---
+
+  def test_geocode_assigns_and_returns_coordinates
+    v = Venue.new(*venue_params(:msg))
+    coords = [40.750354, -73.993371]
+    assert_equal coords, v.geocode
+    assert_equal coords, [v.latitude, v.longitude]
+  end
+
+  def test_reverse_geocode_assigns_and_returns_address
+    v = Landmark.new(*landmark_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_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.coordinates
+  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
+
+  def test_forward_and_reverse_geocoding_on_same_model
+    g = GasStation.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_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
+
+
+  # --- Google ---
+
   def test_result_address_components_of_type
-    results = Geocoder::Lookup.search("Madison Square Garden, New York, NY")
+    result = Geocoder.search("Madison Square Garden, New York, NY")
     assert_equal "Manhattan",
-      results.first.address_components_of_type(:sublocality).first['long_name']
+      result.address_components_of_type(:sublocality).first['long_name']
+  end
+
+  def test_google_result_has_required_attributes
+    result = Geocoder.search("Madison Square Garden, New York, NY")
+    assert_result_has_required_attributes(result)
+  end
+
+  def test_google_returns_nil_when_no_results
+    assert_nil Geocoder.search("no results")
+  end
+
+
+  # --- Yahoo ---
+
+  def test_yahoo_result_components
+    Geocoder::Configuration.lookup = :yahoo
+    result = Geocoder.search("Madison Square Garden, New York, NY")
+    assert_equal "10001", result.postal
+  end
+
+  def test_yahoo_address_formatting
+    Geocoder::Configuration.lookup = :yahoo
+    result = Geocoder.search("Madison Square Garden, New York, NY")
+    assert_equal "Madison Square Garden, New York, NY  10001, United States",
+      result.address
+  end
+
+  def test_yahoo_result_has_required_attributes
+    Geocoder::Configuration.lookup = :yahoo
+    result = Geocoder.search("Madison Square Garden, New York, NY")
+    assert_result_has_required_attributes(result)
+  end
+
+  def test_yahoo_returns_nil_when_no_results
+    Geocoder::Configuration.lookup = :yahoo
+    assert_nil Geocoder.search("no results")
+  end
+
+
+  # --- FreeGeoIp ---
+
+  def test_freegeoip_result_on_ip_address_search
+    result = Geocoder.search("74.200.247.59")
+    assert result.is_a?(Geocoder::Result::Freegeoip)
+  end
+
+  def test_freegeoip_result_components
+    result = Geocoder.search("74.200.247.59")
+    assert_equal "Plano, TX 75093, United States", result.address
+  end
+
+  def test_freegeoip_result_has_required_attributes
+    result = Geocoder.search("74.200.247.59")
+    assert_result_has_required_attributes(result)
+  end
+
+
+  # --- search queries ---
+
+  def test_ip_address_detection
+    assert Geocoder.send(:ip_address?, "232.65.123.94")
+    assert Geocoder.send(:ip_address?, "666.65.123.94") # technically invalid
+    assert !Geocoder.send(:ip_address?, "232.65.123.94.43")
+    assert !Geocoder.send(:ip_address?, "232.65.123")
+  end
+
+  def test_blank_query_detection
+    assert Geocoder.send(:blank_query?, nil)
+    assert Geocoder.send(:blank_query?, "")
+    assert Geocoder.send(:blank_query?, ", , (-)")
+    assert !Geocoder.send(:blank_query?, "a")
+  end
+
+  def test_hash_to_query
+    g = Geocoder::Lookup::Google.new
+    assert_equal "a=1&b=2", g.send(:hash_to_query, {:a => 1, :b => 2})
+  end
+
+
+  private # ------------------------------------------------------------------
+
+  def assert_result_has_required_attributes(result)
+    assert result.coordinates.is_a?(Array)
+    assert result.latitude.is_a?(Float)
+    assert result.longitude.is_a?(Float)
+    assert result.city.is_a?(String)
+    assert result.postal_code.is_a?(String)
+    assert result.country.is_a?(String)
+    assert result.country_code.is_a?(String)
+    assert_not_nil result.address
   end
 end

data/test/test_helper.rb

@@ -1,6 +1,5 @@
 require 'rubygems'
 require 'test/unit'
-require 'active_support/core_ext'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
@@ -28,21 +27,47 @@ module ActiveRecord
     end
 
     def self.scope(*args); end
+
+    def method_missing(name, *args, &block)
+      if name.to_s[-1..-1] == "="
+        write_attribute name.to_s[0...-1], *args
+      else
+        read_attribute name
+      end
+    end
   end
 end
 
 # Require Geocoder after ActiveRecord simulator.
 require 'geocoder'
+require "geocoder/lookups/base"
 
 ##
 # Mock HTTP request to geocoding service.
 #
 module Geocoder
   module Lookup
-    extend self
-    private #-----------------------------------------------------------------
-    def fetch_data(query, reverse = false)
-      File.read(File.join("test", "fixtures", "madison_square_garden.json"))
+    class Google < Base
+      private #-----------------------------------------------------------------
+      def fetch_raw_data(query, reverse = false)
+        file = query == "no results" ? :no_results : :madison_square_garden
+        File.read(File.join("test", "fixtures", "google_#{file}.json"))
+      end
+    end
+
+    class Yahoo < Base
+      private #-----------------------------------------------------------------
+      def fetch_raw_data(query, reverse = false)
+        file = query == "no results" ? :no_results : :madison_square_garden
+        File.read(File.join("test", "fixtures", "yahoo_#{file}.json"))
+      end
+    end
+
+    class Freegeoip < Base
+      private #-----------------------------------------------------------------
+      def fetch_raw_data(query, reverse = false)
+        File.read(File.join("test", "fixtures", "freegeoip_74_200_247_59.json"))
+      end
     end
   end
 end
@@ -58,13 +83,6 @@ class Venue < ActiveRecord::Base
     write_attribute :name, name
     write_attribute :address, address
   end
-
-  ##
-  # If method not found, assume it's an ActiveRecord attribute reader.
-  #
-  def method_missing(name, *args, &block)
-    @attributes[name]
-  end
 end
 
 ##
@@ -79,19 +97,68 @@ class Landmark < ActiveRecord::Base
     write_attribute :latitude, latitude
     write_attribute :longitude, longitude
   end
+end
+
+##
+# Geocoded model with block.
+#
+class Event < ActiveRecord::Base
+  geocoded_by :address do |obj,result|
+    if result
+      obj.coordinates = "#{result.latitude},#{result.longitude}"
+    end
+  end
+
+  def initialize(name, address)
+    super()
+    write_attribute :name, name
+    write_attribute :address, address
+  end
+end
+
+##
+# Reverse geocoded model with block.
+#
+class Party < ActiveRecord::Base
+  reverse_geocoded_by :latitude, :longitude do |obj,result|
+    if result
+      obj.country = result.country_code
+    end
+  end
+
+  def initialize(name, latitude, longitude)
+    super()
+    write_attribute :name, name
+    write_attribute :latitude, latitude
+    write_attribute :longitude, longitude
+  end
+end
+
+##
+# Forward and reverse geocoded model.
+# Should fill in whatever's missing (coords or address).
+#
+class GasStation < ActiveRecord::Base
+  geocoded_by :address, :latitude => :lat, :longitude => :lon
+  reverse_geocoded_by :lat, :lon, :address => :location
 
-  ##
-  # If method not found, assume it's an ActiveRecord attribute reader.
-  #
-  def method_missing(name, *args, &block)
-    @attributes[name]
+  def initialize(name)
+    super()
+    write_attribute :name, name
   end
 end
 
+
 class Test::Unit::TestCase
   def venue_params(abbrev)
     {
       :msg => ["Madison Square Garden", "4 Penn Plaza, New York, NY"]
     }[abbrev]
   end
+
+  def landmark_params(abbrev)
+    {
+      :msg => ["Madison Square Garden", 40.750354, -73.993371]
+    }[abbrev]
+  end
 end