geokit 1.10.0 → 1.11.0

data/test/test_polygon.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-require File.join(File.dirname(__FILE__), "helper")
+require File.join(File.dirname(__FILE__), 'helper')
 
 class PolygonTest < Test::Unit::TestCase #:nodoc: all
   def setup
@@ -53,30 +53,20 @@ class PolygonTest < Test::Unit::TestCase #:nodoc: all
   end
 
   def test_point_inside_poly
-    # puts "\n\nTesting point inside poly... {@polygon.contains?(@point_inside)}\n\n"
     assert @polygon.contains?(@point_inside)
   end
 
   def test_point_outside_poly
-    # puts "\n\nTesting point outside poly... {@polygon.contains?(@point_outside)}\n\n"
     assert !@polygon.contains?(@point_outside)
   end
 
   def test_points_inside_complex_poly
-    # puts "\n\nTesting points INSIDE complex poly..."
-    # puts "\tone: {@complex_polygon.contains?(@complex_inside_one)}"
-    # puts "\ttwo: {@complex_polygon.contains?(@complex_inside_two)}"
-    # puts "\tthree: {@complex_polygon.contains?(@complex_inside_three)}\n\n"
     assert @complex_polygon.contains?(@complex_inside_one)
     assert @complex_polygon.contains?(@complex_inside_two)
     assert @complex_polygon.contains?(@complex_inside_three)
   end
 
   def test_points_outside_complex_poly
-    # puts "\n\nTesting points OUTSIDE complex poly..."
-    # puts "\tone: {@complex_polygon.contains?(@complex_outside_one)}"
-    # puts "\ttwo: {@complex_polygon.contains?(@complex_outside_two)}"
-    # puts "\tthree: {@complex_polygon.contains?(@complex_outside_three)}\n\n"
     assert !@complex_polygon.contains?(@complex_outside_one)
     assert !@complex_polygon.contains?(@complex_outside_two)
     assert !@complex_polygon.contains?(@complex_outside_three)
@@ -85,27 +75,19 @@ class PolygonTest < Test::Unit::TestCase #:nodoc: all
   def test_open_polygon
     # A polygon can only exist of the last point is equal to the first
     # Otherwise, it would just be a line of points.
-
-    # puts "\n\nTesting intialize function to close an open polygon..."
-    # puts "\t Does poly_x[0] (#{@open_polygon.poly_x[0]}) == poly_x[-1] (#{@open_polygon.poly_x[-1]}) ?"
-    # puts "\t Does poly_y[0] (#{@open_polygon.poly_y[0]}) == poly_y[-1] (#{@open_polygon.poly_y[-1]}) ?"
-
     assert @open_polygon.points[0].lng == @open_polygon.points[-1].lng
     assert @open_polygon.points[0].lat == @open_polygon.points[-1].lat
   end
 
   def test_centroid_for_simple_poly
-    @polygon_centroid = Geokit::LatLng.new(45.27463866133501, -93.41400121829719)
-    assert_equal(@polygon.centroid, @polygon_centroid)
+    assert_ll @polygon.centroid, 45.27463866133501, -93.41400121829719
   end
 
   def test_centroid_for_complex_poly
-    @complex_polygon_centroid = Geokit::LatLng.new(45.43622702936517, -93.5352210389731)
-    assert_equal(@complex_polygon.centroid, @complex_polygon_centroid)
+    assert_ll @complex_polygon.centroid, 45.43622702936517, -93.5352210389731
   end
 
   def test_centroid_for_open_poly
-    @open_polygon_centroid = Geokit::LatLng.new(44.95912726688109, -92.7068888186181)
-    assert_equal(@open_polygon.centroid, @open_polygon_centroid)
+    assert_ll @open_polygon.centroid, 44.95912726688109, -92.7068888186181
   end
 end

data/test/test_ripe_geocoder.rb

@@ -1,44 +1,39 @@
-require File.join(File.dirname(__FILE__), "helper")
+require File.join(File.dirname(__FILE__), 'helper')
 
 class RipeGeocoderTest < BaseGeocoderTest #:nodoc: all
   def setup
     super
-    @ip = "74.125.237.209"
-    @ip_au = "118.210.24.54"
+    @ip = '74.125.237.209'
+    @ip_au = '118.210.24.54'
+    @base_url = 'http://stat.ripe.net/data/geoloc/data.json'
   end
 
   def assert_url(expected_url)
-    assert_equal expected_url, TestHelper.get_last_url.gsub(/&oauth_[a-z_]+=[a-zA-Z0-9\-. %]+/, "").gsub("%20", "+")
+    assert_equal expected_url, TestHelper.last_url.gsub(/&oauth_[a-z_]+=[a-zA-Z0-9\-. %]+/, '').gsub('%20', '+')
   end
 
   def test_45
-    VCR.use_cassette("ripe_geocode_45") do
-      res = Geokit::Geocoders::RipeGeocoder.geocode("45.45.45.45")
-      assert !res.success
-    end
+    res = geocode('45.45.45.45', :ripe_geocode_45)
+    assert !res.success
   end
 
   def test_ripe_geocode
-    VCR.use_cassette("ripe_geocode") do
-      url = "http://stat.ripe.net/data/geoloc/data.json?resource=#{@ip}"
-      res = Geokit::Geocoders::RipeGeocoder.geocode(@ip)
-      assert_url url
-      assert_equal res.city, "Mountain View"
-      assert_equal res.state, "CA"
-      assert_equal res.state_code, "CA"
-      assert_equal res.country_code, "US"
-    end
+    url = "#{@base_url}?resource=#{@ip}"
+    res = geocode(@ip, :ripe_geocode)
+    assert_url url
+    assert_equal res.city, 'Mountain View'
+    assert_equal res.state, 'CA'
+    assert_equal res.state_code, 'CA'
+    assert_equal res.country_code, 'US'
   end
 
   def test_ripe_geocode_au
-    VCR.use_cassette("ripe_geocode_au") do
-      url = "http://stat.ripe.net/data/geoloc/data.json?resource=#{@ip_au}"
-      res = Geokit::Geocoders::RipeGeocoder.geocode(@ip_au)
-      assert_url url
-      assert_equal res.city, "Adelaide"
-      assert_equal res.state, nil
-      assert_equal res.state_code, nil
-      assert_equal res.country_code, "AU"
-    end
+    url = "#{@base_url}?resource=#{@ip_au}"
+    res = geocode(@ip_au, :ripe_geocode_au)
+    assert_url url
+    assert_equal res.city, 'Adelaide'
+    assert_equal res.state, nil
+    assert_equal res.state_code, nil
+    assert_equal res.country_code, 'AU'
   end
 end

data/test/test_us_geocoder.rb

@@ -1,55 +1,55 @@
-require File.join(File.dirname(__FILE__), "helper")
-
-Geokit::Geocoders::UsGeocoder.key = nil
+require File.join(File.dirname(__FILE__), 'helper')
 
 class UsGeocoderTest < BaseGeocoderTest #:nodoc: all
-  GEOCODER_US_FULL = "37.792528,-122.393981,100 Spear St,San Francisco,CA,94105"
+  GEOCODER_US_FULL = '37.792528,-122.393981,100 Spear St,San Francisco,CA,94105'
 
   def setup
+    geocoder_class.key = nil
     super
-    @us_full_hash = {city: "San Francisco", state: "CA"}
+    @us_full_hash = {city: 'San Francisco', state: 'CA'}
     @us_full_loc = Geokit::GeoLoc.new(@us_full_hash)
+    @base_url = 'http://geocoder.us/service/csv/geocode'
   end
 
   def test_geocoder_us
     response = MockSuccess.new
     response.expects(:body).returns(GEOCODER_US_FULL)
-    url = "http://geocoder.us/service/csv/geocode?address=#{Geokit::Inflector.url_escape(@address)}"
-    Geokit::Geocoders::UsGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    verify(Geokit::Geocoders::UsGeocoder.geocode(@address))
+    url = "#{@base_url}?address=#{escape(@address)}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    verify(geocode(@address))
   end
 
   def test_geocoder_with_geo_loc
     response = MockSuccess.new
     response.expects(:body).returns(GEOCODER_US_FULL)
-    url = "http://geocoder.us/service/csv/geocode?address=#{Geokit::Inflector.url_escape(@address)}"
-    Geokit::Geocoders::UsGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    verify(Geokit::Geocoders::UsGeocoder.geocode(@us_full_loc))
+    url = "#{@base_url}?address=#{escape(@address)}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    verify(geocode(@us_full_loc))
   end
 
   def test_service_unavailable
     response = MockFailure.new
-    url = "http://geocoder.us/service/csv/geocode?address=#{Geokit::Inflector.url_escape(@address)}"
-    Geokit::Geocoders::UsGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    assert !Geokit::Geocoders::UsGeocoder.geocode(@us_full_loc).success
+    url = "#{@base_url}?address=#{escape(@address)}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    assert !geocode(@us_full_loc).success
   end
 
   def test_all_method
     response = MockSuccess.new
     response.expects(:body).returns(GEOCODER_US_FULL)
-    url = "http://geocoder.us/service/csv/geocode?address=#{Geokit::Inflector.url_escape(@address)}"
-    Geokit::Geocoders::UsGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    res = Geokit::Geocoders::UsGeocoder.geocode(@address)
+    url = "#{@base_url}?address=#{escape(@address)}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    res = geocode(@address)
     assert_equal 1, res.all.size
   end
 
   private
 
   def verify(location)
-    assert_equal "CA", location.state
-    assert_equal "San Francisco", location.city
-    assert_equal "37.792528,-122.393981", location.ll
+    assert_equal 'CA', location.state
+    assert_equal 'San Francisco', location.city
+    assert_equal '37.792528,-122.393981', location.ll
     assert location.is_us?
-    assert_equal "100 Spear St, San Francisco, CA, 94105, US", location.full_address  # slightly different from yahoo
+    assert_equal '100 Spear St, San Francisco, CA, 94105, US', location.full_address  # slightly different from yahoo
   end
 end

data/test/test_useragent.rb

@@ -0,0 +1,46 @@
+require 'test/unit'
+require 'webmock/test_unit'
+
+require File.join(File.dirname(__FILE__), '../lib/geokit.rb')
+
+class UserAgentTest < Test::Unit::TestCase
+
+    NETHTTPDEFAULT          = 'Ruby'
+    NETHTTPDEFAULTHEADERS   = {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3'}
+    TYPHOEUSDEFAULT         = 'Typhoeus - https://github.com/typhoeus/typhoeus'
+    TYPHOEUSDEFAULTHEADERS  = {}
+    TESTAGENT               = 'MyAgent'
+    URL                     = 'http://www.example.com'
+
+    def test_nethttp_useragent_set_to_testagent
+        stub_request(:get, URL).with(:headers => NETHTTPDEFAULTHEADERS.merge('User-Agent' => TESTAGENT))
+
+        Geokit::Geocoders::useragent = TESTAGENT
+        Geokit::NetAdapter::NetHttp.do_get(URL)
+        assert_requested :get, URL
+    end
+
+    def test_nethttp_useragent_set_to_default
+        stub_request(:get, URL).with(:headers => NETHTTPDEFAULTHEADERS.merge('User-Agent' => NETHTTPDEFAULT))
+
+        Geokit::Geocoders::useragent = nil
+        Geokit::NetAdapter::NetHttp.do_get(URL)
+        assert_requested :get, URL
+    end
+
+    def test_typhoeus_set_to_testagent
+        stub_request(:get, URL).with(:headers => TYPHOEUSDEFAULTHEADERS.merge('User-Agent' => TESTAGENT))
+
+        Geokit::Geocoders::useragent = TESTAGENT
+        Geokit::NetAdapter::Typhoeus.do_get(URL)
+        assert_requested :get, URL
+    end
+
+    def test_typhoeus_set_to_default
+        stub_request(:get, URL).with(:headers => TYPHOEUSDEFAULTHEADERS.merge('User-Agent' => TYPHOEUSDEFAULT))
+
+        Geokit::Geocoders::useragent = nil
+        Geokit::NetAdapter::Typhoeus.do_get(URL)
+        assert_requested :get, URL
+    end
+end

data/test/test_yahoo_geocoder.rb

@@ -1,107 +1,95 @@
-require File.join(File.dirname(__FILE__), "helper")
-
-Geokit::Geocoders::YahooGeocoder.key = "dj0yJmk9cXByQVN2WHZmTVhDJmQ9WVdrOVZscG1WVWhOTldrbWNHbzlNakF6TlRJME16UTJNZy0tJnM9Y29uc3VtZXJzZWNyZXQmeD0zNg--"
-Geokit::Geocoders::YahooGeocoder.secret = "SECRET"
+require File.join(File.dirname(__FILE__), 'helper')
 
 class YahooGeocoderTest < BaseGeocoderTest #:nodoc: all
   def setup
     super
-    @yahoo_full_hash = {street_address: "100 Spear St", city: "San Francisco", state: "CA", zip: "94105-1522", country_code: "US"}
-    @yahoo_city_hash = {city: "San Francisco", state: "CA"}
+    @yahoo_full_hash = {street_address: '100 Spear St', city: 'San Francisco', state: 'CA', zip: '94105-1522', country_code: 'US'}
+    @yahoo_city_hash = {city: 'San Francisco', state: 'CA'}
     @yahoo_full_loc = Geokit::GeoLoc.new(@yahoo_full_hash)
     @yahoo_city_loc = Geokit::GeoLoc.new(@yahoo_city_hash)
+
+    key = @keys['yahoo']
+    geocoder_class.key = key['key']
+    geocoder_class.secret = key['secret']
+    @base_url = 'https://yboss.yahooapis.com/geo/placefinder'
   end
 
   def assert_yahoo_url(expected_url)
-    assert_equal expected_url, TestHelper.get_last_url.gsub(/&oauth_[a-z_]+=[a-zA-Z0-9\-. %]+/, "").gsub("%20", "+")
+    assert_equal expected_url, TestHelper.last_url.gsub(/&oauth_[a-z_]+=[a-zA-Z0-9\-. %]+/, '').gsub('%20', '+')
   end
 
   # the testing methods themselves
   def test_yahoo_full_address
-    VCR.use_cassette("yahoo_full") do
-      url = "https://yboss.yahooapis.com/geo/placefinder?flags=J&q=#{Geokit::Inflector.url_escape(@full_address)}"
-    do_full_address_assertions(Geokit::Geocoders::YahooGeocoder.geocode(@full_address))
+    url = "#{@base_url}?flags=J&q=#{escape(@full_address)}"
+    do_full_address_assertions(geocode(@full_address, :yahoo_full))
     assert_yahoo_url url
-    end
   end
 
   def test_yahoo_full_address_accuracy
-    VCR.use_cassette("yahoo_full") do
-      url = "https://yboss.yahooapis.com/geo/placefinder?flags=J&q=#{Geokit::Inflector.url_escape(@full_address)}"
-    res = Geokit::Geocoders::YahooGeocoder.geocode(@full_address)
+    url = "#{@base_url}?flags=J&q=#{escape(@full_address)}"
+    res = geocode(@full_address, :yahoo_full)
     assert_yahoo_url url
     assert_equal 8, res.accuracy
-    end
   end
 
   def test_yahoo_full_address_with_geo_loc
-    VCR.use_cassette("yahoo_full") do
-      url = "https://yboss.yahooapis.com/geo/placefinder?flags=J&q=#{Geokit::Inflector.url_escape(@full_address)}"
-    do_full_address_assertions(Geokit::Geocoders::YahooGeocoder.geocode(@yahoo_full_loc))
+    url = "#{@base_url}?flags=J&q=#{escape(@full_address)}"
+    do_full_address_assertions(geocode(@yahoo_full_loc, :yahoo_full))
     assert_yahoo_url url
-    end
   end
 
   def test_yahoo_city
-    VCR.use_cassette("yahoo_city") do
-      url = "https://yboss.yahooapis.com/geo/placefinder?flags=J&q=#{Geokit::Inflector.url_escape(@address)}"
-    do_city_assertions(Geokit::Geocoders::YahooGeocoder.geocode(@address))
+    url = "#{@base_url}?flags=J&q=#{escape(@address)}"
+    do_city_assertions(geocode(@address, :yahoo_city))
     assert_yahoo_url url
-    end
   end
 
   def test_yahoo_city_accuracy
-    VCR.use_cassette("yahoo_city") do
-      url = "https://yboss.yahooapis.com/geo/placefinder?flags=J&q=#{Geokit::Inflector.url_escape(@address)}"
-    res = Geokit::Geocoders::YahooGeocoder.geocode(@address)
+    url = "#{@base_url}?flags=J&q=#{escape(@address)}"
+    res = geocode(@address, :yahoo_city)
     assert_yahoo_url url
     assert_equal 4, res.accuracy
-    end
   end
 
   def test_yahoo_city_with_geo_loc
-    VCR.use_cassette("yahoo_city") do
-      url = "https://yboss.yahooapis.com/geo/placefinder?flags=J&q=#{Geokit::Inflector.url_escape(@address)}"
-    do_city_assertions(Geokit::Geocoders::YahooGeocoder.geocode(@yahoo_city_loc))
+    url = "#{@base_url}?flags=J&q=#{escape(@address)}"
+    do_city_assertions(geocode(@yahoo_city_loc, :yahoo_city))
     assert_yahoo_url url
-    end
   end
 
   def test_no_results
-    no_results_address = "ZZ, ZZ, ZZ"
-    VCR.use_cassette("yahoo_no_results") do
-      url = "https://yboss.yahooapis.com/geo/placefinder?flags=J&q=#{Geokit::Inflector.url_escape(no_results_address)}"
-    result = Geokit::Geocoders::YahooGeocoder.geocode(no_results_address)
+    no_results_address = 'ZZ, ZZ, ZZ'
+    url = "#{@base_url}?flags=J&q=#{escape(no_results_address)}"
+    result = geocode(no_results_address, :yahoo_no_results)
     assert_yahoo_url url
-    assert_equal ",", result.ll
-    end
+    assert_equal ',', result.ll
   end
 
   def test_service_unavailable
     response = MockFailure.new
-    Geokit::Geocoders::YahooGeocoder.expects(:call_geocoder_service).returns(response)
-    assert !Geokit::Geocoders::YahooGeocoder.geocode(@yahoo_city_loc).success
+    geocoder_class.expects(:call_geocoder_service).returns(response)
+    assert !geocode(@yahoo_city_loc).success
   end
 
   private
 
   # next two methods do the assertions for both address-level and city-level lookups
   def do_full_address_assertions(res)
-    assert_equal "CA", res.state
-    assert_equal "San Francisco", res.city
+    assert_equal 'CA', res.state
+    assert_equal 'San Francisco', res.city
     assert_array_in_delta [37.792332, -122.393791], res.to_a
     assert res.is_us?
-    assert_equal "100 Spear St, San Francisco, CA, 94105-1578, US", res.full_address
-    assert_equal "yahoo", res.provider
+    assert_equal '100 Spear St, San Francisco, CA, 94105-1578, US', res.full_address
+    assert_equal 'yahoo', res.provider
   end
 
   def do_city_assertions(res)
-    assert_equal "CA", res.state
-    assert_equal "San Francisco", res.city
+    assert_equal 'CA', res.state
+    assert_equal 'San Francisco', res.city
     assert_array_in_delta [37.77713, -122.41964], res.to_a
     assert res.is_us?
-    assert_equal "San Francisco, CA, US", res.full_address
+    assert_equal 'San Francisco, CA, US', res.full_address
     assert_nil res.street_address
-    assert_equal "yahoo", res.provider
+    assert_equal 'yahoo', res.provider
   end
 end

data/test/test_yandex_geocoder.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
-require File.join(File.dirname(__FILE__), "helper")
+require File.join(File.dirname(__FILE__), 'helper')
 
 class YandexGeocoderTest < BaseGeocoderTest #:nodoc: all
   YANDEX_FULL = <<-EOF.strip
@@ -7,7 +7,7 @@ class YandexGeocoderTest < BaseGeocoderTest #:nodoc: all
   EOF
 
   YANDEX_REGION = <<-EOF.strip
-    {"response":{"GeoObjectCollection":{"metaDataProperty":{"GeocoderResponseMetaData":{"request":"Ростов-на-Дону, ул. Станиславского, д.21","found":"1","results":"10"}},"featureMember":[{"GeoObject":{"metaDataProperty":{"GeocoderMetaData":{"kind":"house","text":"Россия, Ростовская область, город Ростов-на-Дону, улица Станиславского, 21","precision":"exact","AddressDetails":{"Country":{"AddressLine":"Ростовская область, город Ростов-на-Дону, улица Станиславского, 21","CountryNameCode":"RU","CountryName":"Россия","AdministrativeArea":{"AdministrativeAreaName":"Ростовская область","Locality":{"LocalityName":"город Ростов-на-Дону","Thoroughfare":{"ThoroughfareName":"улица Станиславского","Premise":{"PremiseNumber":"21"}}}}}}}},"description":"город Ростов-на-Дону, Ростовская область, Россия","name":"улица Станиславского, 21","boundedBy":{"Envelope":{"lowerCorner":"39.701349 47.214507","upperCorner":"39.705446 47.217298"}},"Point":{"pos":"39.703398 47.215903"}}}]}}}
+    {"response":{"GeoObjectCollection":{"metaDataProperty":{"GeocoderResponseMetaData":{"request":"Ростов-на-Дону, ул. Станиславского, д.21","found":"2","results":"10"}},"featureMember":[{"GeoObject":{"metaDataProperty":{"GeocoderMetaData":{"kind":"house","text":"Россия, Ростов-на-Дону, улица Станиславского, 21","precision":"exact","AddressDetails":{"Country":{"AddressLine":"Ростов-на-Дону, улица Станиславского, 21","CountryNameCode":"RU","CountryName":"Россия","AdministrativeArea":{"AdministrativeAreaName":"Ростовская область","SubAdministrativeArea":{"SubAdministrativeAreaName":"городской округ Ростов-на-Дону","Locality":{"LocalityName":"Ростов-на-Дону","Thoroughfare":{"ThoroughfareName":"улица Станиславского","Premise":{"PremiseNumber":"21"}}}}}}}}},"description":"Ростов-на-Дону, Россия","name":"улица Станиславского, 21","boundedBy":{"Envelope":{"lowerCorner":"39.695043 47.210284","upperCorner":"39.7115 47.221497"}},"Point":{"pos":"39.703272 47.21589"}}}]}}}
   EOF
 
   YANDEX_CITY = <<-EOF.strip
@@ -22,69 +22,71 @@ class YandexGeocoderTest < BaseGeocoderTest #:nodoc: all
     super
     @full_address = "Москва, улица Новый Арбат, дом 24"
     @address = "город Москва"
+    @base_url = 'https://geocode-maps.yandex.ru/1.x'
   end
 
   # the testing methods themselves
   def test_yandex_full_address
     response = MockSuccess.new
     response.expects(:body).returns(YANDEX_FULL)
-    url = "https://geocode-maps.yandex.ru/1.x/?geocode=#{Geokit::Inflector.url_escape(@full_address)}&format=json"
-    Geokit::Geocoders::YandexGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    res = Geokit::Geocoders::YandexGeocoder.geocode(@full_address)
+    url = "#{@base_url}/?geocode=#{escape(@full_address)}&format=json"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    res = geocode(@full_address)
 
-    assert_equal "yandex", res.provider
+    assert_equal 'yandex', res.provider
     assert_equal "улица Новый Арбат, 24", res.street_address
     assert_equal "Москва", res.city
     assert_equal 55.753083, res.lat
     assert_equal 37.587614, res.lng
-    assert_equal "RU", res.country_code
+    assert_equal 'RU', res.country_code
     assert res.success
   end
 
-  def test_yandex_full_address_with_region
+  def test_yandex_full_address_with_region_and_district
     region_address = "Ростов-на-Дону, ул. Станиславского, д.21"
     response = MockSuccess.new
     response.expects(:body).returns(YANDEX_REGION)
-    url = "https://geocode-maps.yandex.ru/1.x/?geocode=#{Geokit::Inflector.url_escape(region_address)}&format=json"
-    Geokit::Geocoders::YandexGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    res = Geokit::Geocoders::YandexGeocoder.geocode(region_address)
+    url = "#{@base_url}/?geocode=#{escape(region_address)}&format=json"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    res = geocode(region_address)
 
-    assert_equal "yandex", res.provider
+    assert_equal 'yandex', res.provider
     assert_equal "улица Станиславского, 21", res.street_address
-    assert_equal "город Ростов на Дону", res.city
+    assert_equal "Ростов на Дону", res.city
     assert_equal "Ростовская область", res.state
-    assert_equal 47.215903, res.lat
-    assert_equal 39.703398, res.lng
-    assert_equal "RU", res.country_code
+    assert_equal "городской округ Ростов-на-Дону", res.district
+    assert_equal 47.21589, res.lat
+    assert_equal 39.703272, res.lng
+    assert_equal 'RU', res.country_code
     assert res.success
   end
 
   def test_yandex_city
     response = MockSuccess.new
     response.expects(:body).returns(YANDEX_CITY)
-    url = "https://geocode-maps.yandex.ru/1.x/?geocode=#{Geokit::Inflector.url_escape(@address)}&format=json"
-    Geokit::Geocoders::YandexGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    res = Geokit::Geocoders::YandexGeocoder.geocode(@address)
+    url = "#{@base_url}/?geocode=#{escape(@address)}&format=json"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    res = geocode(@address)
 
-    assert_equal "yandex", res.provider
-    assert_equal "city", res.precision
+    assert_equal 'yandex', res.provider
+    assert_equal 'city', res.precision
     assert_equal "Москва", res.city
     assert_equal 55.755773, res.lat
     assert_equal 37.617761, res.lng
-    assert_equal "RU", res.country_code
+    assert_equal 'RU', res.country_code
     assert res.success
   end
 
   def test_no_results
-    no_results_address = "ZZ, ZZ, ZZ"
+    no_results_address = 'ZZ, ZZ, ZZ'
     # no_results_full_hash = {:street_address=>"ZZ", :city=>"ZZ", :state=>"ZZ"}
     # no_results_full_loc = Geokit::GeoLoc.new(no_results_full_hash)
 
     response = MockSuccess.new
     response.expects(:body).returns(YANDEX_NO_RESULTS)
-    url = "https://geocode-maps.yandex.ru/1.x/?geocode=#{Geokit::Inflector.url_escape(no_results_address)}&format=json"
-    Geokit::Geocoders::YandexGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    result = Geokit::Geocoders::YandexGeocoder.geocode(no_results_address)
-    assert_equal ",", result.ll
+    url = "#{@base_url}/?geocode=#{escape(no_results_address)}&format=json"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    result = geocode(no_results_address)
+    assert_equal ',', result.ll
   end
 end