geocoder 1.0.1 → 1.0.2

data/test/https_test.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+require 'test_helper'
+
+class HttpsTest < Test::Unit::TestCase
+
+  def setup
+    Geocoder::Configuration.set_defaults
+  end
+
+  def test_uses_https_for_secure_query
+    Geocoder::Configuration.use_https = true
+    g = Geocoder::Lookup::Google.new
+    assert_match /^https:/, g.send(:query_url, {:a => 1, :b => 2})
+  end
+
+  def test_uses_http_by_default
+    g = Geocoder::Lookup::Google.new
+    assert_match /^http:/, g.send(:query_url, {:a => 1, :b => 2})
+  end
+end

data/test/input_handling_test.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+require 'test_helper'
+
+class InputHandlingTest < Test::Unit::TestCase
+
+  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?, "\t  ")
+    assert !Geocoder.send(:blank_query?, "a")
+    assert !Geocoder.send(:blank_query?, "Москва") # no ASCII characters
+  end
+
+  def test_coordinates_detection
+    lookup = Geocoder::Lookup::Google.new
+    assert lookup.send(:coordinates?, "51.178844,5")
+    assert lookup.send(:coordinates?, "51.178844, -1.826189")
+    assert !lookup.send(:coordinates?, "232.65.123")
+  end
+
+  def test_does_not_choke_on_nil_address
+    all_lookups.each do |l|
+      Geocoder::Configuration.lookup = l
+      assert_nothing_raised { Venue.new("Venue", nil).geocode }
+    end
+  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/lookup_test.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require 'test_helper'
+
+class LookupTest < Test::Unit::TestCase
+
+  def test_search_returns_empty_array_when_no_results
+    street_lookups.each do |l|
+      Geocoder::Configuration.lookup = l
+      assert_equal [], Geocoder.search("no results"),
+        "Lookup #{l} does not return empty array when no results."
+    end
+  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
+
+  def test_google_api_key
+    Geocoder::Configuration.api_key = "MY_KEY"
+    g = Geocoder::Lookup::Google.new
+    assert_match "key=MY_KEY", g.send(:query_url, "Madison Square Garden, New York, NY  10001, United States")
+  end
+
+  def test_yahoo_app_id
+    Geocoder::Configuration.api_key = "MY_KEY"
+    g = Geocoder::Lookup::Yahoo.new
+    assert_match "appid=MY_KEY", g.send(:query_url, "Madison Square Garden, New York, NY  10001, United States")
+  end
+end

data/test/method_aliases_test.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require 'test_helper'
+
+class MethodAliasesTest < Test::Unit::TestCase
+
+  def setup
+    Geocoder::Configuration.set_defaults
+  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
+
+  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,35 @@
+# encoding: utf-8
+require 'test_helper'
+
+begin
+require 'mongoid'
+require 'mongoid_test_helper'
+
+class MongoidTest < Test::Unit::TestCase
+
+  def setup
+    Geocoder::Configuration.set_defaults
+  end
+
+  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)
+    assert_equal p.selector[:location]['$nearSphere'], location.reverse
+  end
+end
+
+rescue LoadError => crash
+  warn 'Mongoid not installed, not tested.'
+end

data/test/mongoid_test_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+Mongoid.configure do |config| 
+  config.logger = Logger.new($stderr, :debug)
+end 
+
+##
+# Geocoded model.
+#
+class Place
+  include Mongoid::Document
+  include Geocoder::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

data/test/proxy_test.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require 'test_helper'
+
+class ProxyTest < Test::Unit::TestCase
+
+  def setup
+    Geocoder::Configuration.set_defaults
+  end
+
+  def test_uses_proxy_when_specified
+    Geocoder::Configuration.http_proxy = 'localhost'
+    lookup = Geocoder::Lookup::Google.new
+    assert lookup.send(:http_client).proxy_class?
+  end
+
+  def test_doesnt_use_proxy_when_not_specified
+    lookup = Geocoder::Lookup::Google.new
+    assert !lookup.send(:http_client).proxy_class?
+  end
+
+  def test_exception_raised_on_bad_proxy_url
+    Geocoder::Configuration.http_proxy = ' \\_O< Quack Quack'
+    assert_raise Geocoder::ConfigurationError do
+      Geocoder::Lookup::Google.new.send(:http_client)
+    end
+  end
+end

data/test/result_test.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+require 'test_helper'
+
+class ResultTest < Test::Unit::TestCase
+
+  def test_result_has_required_attributes
+    all_lookups.each do |l|
+      Geocoder::Configuration.lookup = l
+      result = Geocoder.search([45.423733, -75.676333]).first
+      assert_result_has_required_attributes(result)
+    end
+  end
+
+
+  private # ------------------------------------------------------------------
+
+  def assert_result_has_required_attributes(result)
+    m = "Lookup #{Geocoder::Configuration.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

data/test/services_test.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+require 'test_helper'
+
+class ServicesTest < Test::Unit::TestCase 
+
+  def setup
+    Geocoder::Configuration.set_defaults
+  end
+
+
+  # --- Google ---
+
+  def test_google_result_components
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "Manhattan",
+      result.address_components_of_type(:sublocality).first['long_name']
+  end
+
+  def test_google_returns_city_when_no_locality_in_result
+    result = Geocoder.search("no locality").first
+    assert_equal "Haram", result.city
+  end
+
+  def test_google_city_results_returns_nil_if_no_matching_component_types
+    result = Geocoder.search("no city data").first
+    assert_equal nil, result.city
+  end
+
+
+  # --- Yahoo ---
+
+  def test_yahoo_result_components
+    Geocoder::Configuration.lookup = :yahoo
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "10001", result.postal_code
+  end
+
+  def test_yahoo_address_formatting
+    Geocoder::Configuration.lookup = :yahoo
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "Madison Square Garden, New York, NY  10001, United States",
+      result.address
+  end
+
+
+  # --- Yandex ---
+
+  def test_yandex_with_invalid_key
+    # keep test output clean: suppress timeout warning
+    orig = $VERBOSE; $VERBOSE = nil
+    Geocoder::Configuration.lookup = :yandex
+    assert_equal [], Geocoder.search("invalid key")
+    $VERBOSE = orig
+  end
+
+
+  # --- Geocoder.ca ---
+
+  def test_geocoder_ca_result_components
+    Geocoder::Configuration.lookup = :geocoder_ca
+    result = Geocoder.search([45.423733, -75.676333]).first
+    assert_equal "CA", result.country_code
+    assert_equal "289 Somerset ST E, Ottawa, ON K1N6W1, Canada", result.address
+  end
+
+
+  # --- FreeGeoIp ---
+
+  def test_freegeoip_result_on_ip_address_search
+    result = Geocoder.search("74.200.247.59").first
+    assert result.is_a?(Geocoder::Result::Freegeoip)
+  end
+
+  def test_freegeoip_result_components
+    result = Geocoder.search("74.200.247.59").first
+    assert_equal "Plano, TX 75093, United States", result.address
+  end
+
+
+  # --- Bing ---
+
+  def test_bing_result_components
+    Geocoder::Configuration.lookup = :bing
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "Madison Square Garden, NY", result.address
+    assert_equal "NY", result.state
+    assert_equal "New York", result.city
+  end
+
+  def test_bing_no_results
+    Geocoder::Configuration.lookup = :bing
+    results = Geocoder.search("no results")
+    assert_equal 0, results.length
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: geocoder
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors: 
 - Alex Reisner
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-17 00:00:00 -04:00
+date: 2011-06-25 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -44,6 +44,8 @@ files:
 - lib/geocoder/lookups/yandex.rb
 - lib/geocoder/models/active_record.rb
 - lib/geocoder/models/base.rb
+- lib/geocoder/models/mongo_base.rb
+- lib/geocoder/models/mongo_mapper.rb
 - lib/geocoder/models/mongoid.rb
 - lib/geocoder/railtie.rb
 - lib/geocoder/request.rb
@@ -56,9 +58,15 @@ files:
 - lib/geocoder/results/yandex.rb
 - lib/geocoder/stores/active_record.rb
 - lib/geocoder/stores/base.rb
+- lib/geocoder/stores/mongo_base.rb
+- lib/geocoder/stores/mongo_mapper.rb
 - lib/geocoder/stores/mongoid.rb
 - lib/geocoder/version.rb
 - lib/tasks/geocoder.rake
+- test/calculations_test.rb
+- test/configuration_test.rb
+- test/custom_block_test.rb
+- test/error_handling_test.rb
 - test/fixtures/bing_madison_square_garden.json
 - test/fixtures/bing_no_results.json
 - test/fixtures/bing_reverse.json
@@ -78,6 +86,15 @@ files:
 - test/fixtures/yandex_kremlin.json
 - test/fixtures/yandex_no_results.json
 - test/geocoder_test.rb
+- test/https_test.rb
+- test/input_handling_test.rb
+- test/lookup_test.rb
+- test/method_aliases_test.rb
+- test/mongoid_test.rb
+- test/mongoid_test_helper.rb
+- test/proxy_test.rb
+- test/result_test.rb
+- test/services_test.rb
 - test/test_helper.rb
 has_rdoc: true
 homepage: http://www.rubygeocoder.com
@@ -103,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.1
+rubygems_version: 1.6.1
 signing_key: 
 specification_version: 3
 summary: Complete geocoding solution for Ruby.