geokit 1.10.0 → 1.11.0

data/test/test_multi_geocoder.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), "helper")
+require File.join(File.dirname(__FILE__), 'helper')
 
 Geokit::Geocoders.provider_order = [:google, :bing, :us]
 
@@ -44,9 +44,9 @@ class MultiGeocoderTest < BaseGeocoderTest #:nodoc: all
     t1, t2 = Geokit::Geocoders.provider_order, Geokit::Geocoders.ip_provider_order # will need to reset after
     Geokit::Geocoders.provider_order = [:google]
     Geokit::Geocoders.ip_provider_order = [:geo_plugin]
-    Geokit::Geocoders::GoogleGeocoder.expects(:geocode).with("").returns(@failure)
+    Geokit::Geocoders::GoogleGeocoder.expects(:geocode).with('').returns(@failure)
     Geokit::Geocoders::GeoPluginGeocoder.expects(:geocode).never
-    assert_equal @failure, Geokit::Geocoders::MultiGeocoder.geocode("")
+    assert_equal @failure, Geokit::Geocoders::MultiGeocoder.geocode('')
     Geokit::Geocoders.provider_order, Geokit::Geocoders.ip_provider_order = t1, t2 # reset to orig values
   end
 
@@ -87,8 +87,8 @@ class MultiGeocoderTest < BaseGeocoderTest #:nodoc: all
   def test_reverse_geocode_with_blank_latlng
     t1 = Geokit::Geocoders.provider_order # will need to reset after
     Geokit::Geocoders.provider_order = [:google]
-    Geokit::Geocoders::GoogleGeocoder.expects(:reverse_geocode).with("").returns(@failure)
-    assert_equal @failure, Geokit::Geocoders::MultiGeocoder.reverse_geocode("")
+    Geokit::Geocoders::GoogleGeocoder.expects(:reverse_geocode).with('').returns(@failure)
+    assert_equal @failure, Geokit::Geocoders::MultiGeocoder.reverse_geocode('')
     Geokit::Geocoders.provider_order = t1 # reset to orig values
   end
 

data/test/test_multi_ip_geocoder.rb

@@ -1,11 +1,11 @@
-require File.join(File.dirname(__FILE__), "helper")
+require File.join(File.dirname(__FILE__), 'helper')
 
 Geokit::Geocoders.ip_provider_order = [:geo_plugin, :ip]
 
 class MultiIpGeocoderTest < BaseGeocoderTest #:nodoc: all
   def setup
-    @ip_address = "10.10.10.10"
-    @success = Geokit::GeoLoc.new({city: "SAN FRANCISCO", state: "CA", country_code: "US", lat: 37.7742, lng: -122.417068})
+    @ip_address = '10.10.10.10'
+    @success = Geokit::GeoLoc.new({city: 'SAN FRANCISCO', state: 'CA', country_code: 'US', lat: 37.7742, lng: -122.417068})
     @success.success = true
     @failure = Geokit::GeoLoc.new
   end

data/test/test_net_adapter.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), "helper")
+require File.join(File.dirname(__FILE__), 'helper')
 
 # Base class for testing geocoders.
 class NetAdapterTest < Test::Unit::TestCase #:nodoc: all
@@ -23,12 +23,12 @@ class NetAdapterTest < Test::Unit::TestCase #:nodoc: all
   end
 
   RESULT = '{"name":"json"}'
-  RESULT_HASH = {"name" => "json"}
+  RESULT_HASH = {'name' => 'json'}
 
   # Defines common test fixtures.
   def setup
-    @url = "http://www.cacheme.com"
-    @address = "San Francisco, CA"
+    @url = 'http://www.cacheme.com'
+    @address = 'San Francisco, CA'
   end
 
   def test_cache

data/test/test_opencage_geocoder.rb

@@ -1,106 +1,97 @@
 # encoding: utf-8
-require File.join(File.dirname(__FILE__), "helper")
+require File.join(File.dirname(__FILE__), 'helper')
 
 class OpencageGeocoderTest < BaseGeocoderTest #:nodoc: all
   def setup
     super
-    @opencage_full_hash = {street_address: "100 Spear St", city: "San Francisco", state: "CA", zip: "94105", country_code: "US"}
-    @opencage_city_hash = {city: "San Francisco", state: "CA"}
+    @opencage_full_hash = {street_address: '100 Spear St', city: 'San Francisco', state: 'CA', zip: '94105', country_code: 'US'}
+    @opencage_city_hash = {city: 'San Francisco', state: 'CA'}
     @opencage_full_loc = Geokit::GeoLoc.new(@opencage_full_hash)
     @opencage_city_loc = Geokit::GeoLoc.new(@opencage_city_hash)
 
     # Note: This is not a real key because having real keys on github
     # is not advised
-    key = "someopencageapikey"
-    Geokit::Geocoders::OpencageGeocoder.key = key
+    key = 'someopencageapikey'
+    geocoder_class.key = key
+    @base_url = 'https://api.opencagedata.com/geocode/v1/json'
   end
 
   def test_opencage_full_address
-    VCR.use_cassette("opencage_full") do
-      url = "https://api.opencagedata.com/geocode/v1/json?key=someopencageapikey&query=100+Spear+St%2C+San+Francisco%2C+CA%2C+94105%2C+US&no_annotations=1"
-      TestHelper.expects(:last_url).with(url)
-      res = Geokit::Geocoders::OpencageGeocoder.geocode(@opencage_full_loc)
-
-      assert_equal "California", res.state
-      assert_equal "San Francisco", res.city
-      assert_array_in_delta [37.7921509, -122.394], res.to_a
-      assert res.is_us?
-      assert_equal "Spear Street 100, San Francisco, California, 94103, US", res.full_address
-      assert_equal "opencage", res.provider
-    end
+    url = "#{@base_url}?key=someopencageapikey&query=100+Spear+St%2C+San+Francisco%2C+CA%2C+94105%2C+US&no_annotations=1"
+    TestHelper.expects(:last_url).with(url)
+    res = geocode(@opencage_full_loc, :opencage_full)
+
+    assert_equal 'California', res.state
+    assert_equal 'San Francisco', res.city
+    assert_array_in_delta [37.7921509, -122.394], res.to_a
+    assert res.is_us?
+    assert_equal 'Spear Street 100, San Francisco, California, 94103, US', res.full_address
+    assert_equal 'opencage', res.provider
   end
 
   def test_opencage_city
-    VCR.use_cassette("opencage_city") do
-      url = "https://api.opencagedata.com/geocode/v1/json?key=someopencageapikey&query=San+Francisco%2C+CA&no_annotations=1"
-      TestHelper.expects(:last_url).with(url)
-      res = Geokit::Geocoders::OpencageGeocoder.geocode(@opencage_city_loc)
-
-      assert_equal "California", res.state
-      assert_equal "San Francisco", res.city
-      assert_array_in_delta [37.7792768, -122.4192704], res.to_a
-      assert res.is_us?
-      assert_equal "San Francisco, California, US", res.full_address
-      assert_equal "opencage", res.provider
-    end
+    url = "#{@base_url}?key=someopencageapikey&query=San+Francisco%2C+CA&no_annotations=1"
+    TestHelper.expects(:last_url).with(url)
+    res = geocode(@opencage_city_loc, :opencage_city)
+
+    assert_equal 'California', res.state
+    assert_equal 'San Francisco', res.city
+    assert_array_in_delta [37.7792768, -122.4192704], res.to_a
+    assert res.is_us?
+    assert_equal 'San Francisco, California, US', res.full_address
+    assert_equal 'opencage', res.provider
   end
 
   def test_opencage_reverse
-    VCR.use_cassette("opencage_reverse_madrid") do
-      location = Geokit::GeoLoc.new
-      location.lat, location.lng = "40.4167413", "-3.7032498"     # Madrid
+    location = Geokit::GeoLoc.new
+    location.lat, location.lng = '40.4167413', '-3.7032498'     # Madrid
 
-      url = "https://api.opencagedata.com/geocode/v1/json?key=someopencageapikey&query=40.4167413%2C-3.7032498&no_annotations=1"
-      TestHelper.expects(:last_url).with(url)
-      res = Geokit::Geocoders::OpencageGeocoder.geocode(location.ll)
+    url = "#{@base_url}?key=someopencageapikey&query=40.4167413%2C-3.7032498&no_annotations=1"
+    TestHelper.expects(:last_url).with(url)
+    res = geocode(location.ll, :opencage_reverse_madrid)
 
-      assert_equal "ES", res.country_code
-      assert_equal "opencage", res.provider
+    assert_equal 'ES', res.country_code
+    assert_equal 'opencage', res.provider
 
-      assert_equal "Madrid", res.city
-      assert_equal "Community of Madrid", res.state
+    assert_equal 'Madrid', res.city
+    assert_equal 'Community of Madrid', res.state
 
-      assert_equal "Spain", res.country
-      assert_equal true, res.success
+    assert_equal 'Spain', res.country
+    assert_equal true, res.success
 
-      assert_equal "Calle De Zurbano, Chamberí, Madrid, Community of Madrid, 28036, ES", res.full_address
-      assert_equal 28_036, res.zip
-      assert_equal "Calle De Zurbano", res.street_address
-    end
+    assert_equal "Calle De Zurbano, Chamberí, Madrid, Community of Madrid, 28036, ES", res.full_address
+    assert_equal 28_036, res.zip
+    assert_equal 'Calle De Zurbano', res.street_address
   end
 
   def test_opencage_reverse2
-    VCR.use_cassette("opencage_reverse_prilep") do
-      location = Geokit::GeoLoc.new
-      location.lat, location.lng = "41.3527177", "21.5497808"
+    location = Geokit::GeoLoc.new
+    location.lat, location.lng = '41.3527177', '21.5497808'
 
-      url = "https://api.opencagedata.com/geocode/v1/json?key=someopencageapikey&query=41.3527177%2C21.5497808&no_annotations=1"
-      TestHelper.expects(:last_url).with(url)
-      res = Geokit::Geocoders::OpencageGeocoder.geocode(location.ll)
+    url = "#{@base_url}?key=someopencageapikey&query=41.3527177%2C21.5497808&no_annotations=1"
+    TestHelper.expects(:last_url).with(url)
+    res = geocode(location.ll, :opencage_reverse_prilep)
 
-      assert_equal "MK", res.country_code
-      assert_equal "opencage", res.provider
+    assert_equal 'MK', res.country_code
+    assert_equal 'opencage', res.provider
 
-      assert_equal "Prilep", res.city
-      assert_equal "Pelagonia Region", res.state
+    assert_equal 'Prilep', res.city
+    assert_equal 'Pelagonia Region', res.state
 
-      assert_equal "Macedonia", res.country
-      assert_equal 10, res.precision
-      assert_equal true, res.success
+    assert_equal 'Macedonia', res.country
+    assert_equal 10, res.precision
+    assert_equal true, res.success
 
-      assert_equal "Прилепски Бранители, Prilep, Pelagonia Region, MK", res.full_address
-      assert_equal "Прилепски Бранители", res.street_address
-    end
+    assert_equal "Прилепски Бранители, Prilep, Pelagonia Region, MK", res.full_address
+    assert_equal "Прилепски Бранители", res.street_address
   end
 
   # check if the results are in Spanish if &language=es
   def test_language_response
-    VCR.use_cassette("opencage_language_response_es") do
-      url = "https://api.opencagedata.com/geocode/v1/json?key=someopencageapikey&language=es&query=London&no_annotations=1"
-      TestHelper.expects(:last_url).with(url)
-      language_result = Geokit::Geocoders::OpencageGeocoder.geocode("London", language: "es")
+    url = "#{@base_url}?key=someopencageapikey&language=es&query=London&no_annotations=1"
+    TestHelper.expects(:last_url).with(url)
+    language_result = geocode('London', :opencage_language_response_es, language: 'es')
 
-      assert_equal "Londres", language_result.city
-    end
+    assert_equal 'Londres', language_result.city
   end
 end

data/test/test_openstreetmap_geocoder.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-require File.join(File.dirname(__FILE__), "helper")
+require File.join(File.dirname(__FILE__), 'helper')
 
 class OSMGeocoderTest < BaseGeocoderTest #:nodoc: all
   OSM_FULL = <<-EOF.strip
@@ -20,95 +20,97 @@ class OSMGeocoderTest < BaseGeocoderTest #:nodoc: all
 
   def setup
     super
-    @osm_full_hash = {street_address: "100 Spear St", city: "San Francisco", state: "CA", zip: "94105", country_code: "US"}
-    @osm_city_hash = {city: "San Francisco", state: "CA"}
+    @osm_full_hash = {street_address: '100 Spear St', city: 'San Francisco', state: 'CA', zip: '94105', country_code: 'US'}
+    @osm_city_hash = {city: 'San Francisco', state: 'CA'}
     @osm_full_loc = Geokit::GeoLoc.new(@osm_full_hash)
     @osm_city_loc = Geokit::GeoLoc.new(@osm_city_hash)
+    @base_url = 'http://nominatim.openstreetmap.org/search'
+    @reverse_url = 'http://nominatim.openstreetmap.org/reverse'
   end
 
   # the testing methods themselves
   def test_osm_full_address
     response = MockSuccess.new
     response.expects(:body).returns(OSM_FULL)
-    url = "http://nominatim.openstreetmap.org/search?format=json&polygon=0&addressdetails=1&q=#{Geokit::Inflector.url_escape(@full_address_short_zip)}"
-    Geokit::Geocoders::OSMGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    do_full_address_assertions(Geokit::Geocoders::OSMGeocoder.geocode(@full_address_short_zip))
+    url = "#{@base_url}?format=json&polygon=0&addressdetails=1&q=#{escape(@full_address_short_zip)}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    do_full_address_assertions(geocode(@full_address_short_zip))
   end
 
   def test_osm_full_address_accuracy
     response = MockSuccess.new
     response.expects(:body).returns(OSM_FULL)
-    url = "http://nominatim.openstreetmap.org/search?format=json&polygon=0&addressdetails=1&q=#{Geokit::Inflector.url_escape(@full_address_short_zip)}"
-    Geokit::Geocoders::OSMGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    res = Geokit::Geocoders::OSMGeocoder.geocode(@full_address_short_zip)
-    assert_equal "house", res.accuracy
+    url = "#{@base_url}?format=json&polygon=0&addressdetails=1&q=#{escape(@full_address_short_zip)}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    res = geocode(@full_address_short_zip)
+    assert_equal 'house', res.accuracy
   end
 
   def test_osm_full_address_with_geo_loc
     response = MockSuccess.new
     response.expects(:body).returns(OSM_FULL)
-    url = "http://nominatim.openstreetmap.org/search?format=json&polygon=0&addressdetails=1&q=#{Geokit::Inflector.url_escape(@full_address_short_zip)}"
-    Geokit::Geocoders::OSMGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    do_full_address_assertions(Geokit::Geocoders::OSMGeocoder.geocode(@osm_full_loc))
+    url = "#{@base_url}?format=json&polygon=0&addressdetails=1&q=#{escape(@full_address_short_zip)}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    do_full_address_assertions(geocode(@osm_full_loc))
   end
 
   def test_osm_city
     response = MockSuccess.new
     response.expects(:body).returns(OSM_CITY)
-    url = "http://nominatim.openstreetmap.org/search?format=json&polygon=0&addressdetails=1&q=#{Geokit::Inflector.url_escape(@address)}"
-    Geokit::Geocoders::OSMGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    do_city_assertions(Geokit::Geocoders::OSMGeocoder.geocode(@address))
+    url = "#{@base_url}?format=json&polygon=0&addressdetails=1&q=#{escape(@address)}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    do_city_assertions(geocode(@address))
   end
 
   def test_osm_city_with_accept_language
     response = MockSuccess.new
     response.expects(:body).returns(OSM_CITY)
-    url = "http://nominatim.openstreetmap.org/search?format=json&polygon=0&accept-language=pt-br&addressdetails=1&q=#{Geokit::Inflector.url_escape(@address)}"
-    Geokit::Geocoders::OSMGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    do_city_assertions(Geokit::Geocoders::OSMGeocoder.geocode(@address, {:'accept-language' => "pt-br"}))
+    url = "#{@base_url}?format=json&polygon=0&accept-language=pt-br&addressdetails=1&q=#{escape(@address)}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    do_city_assertions(geocode(@address, {:'accept-language' => 'pt-br'}))
   end
 
   def test_osm_city_accuracy
     response = MockSuccess.new
     response.expects(:body).returns(OSM_CITY)
-    url = "http://nominatim.openstreetmap.org/search?format=json&polygon=0&addressdetails=1&q=#{Geokit::Inflector.url_escape(@address)}"
-    Geokit::Geocoders::OSMGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    res = Geokit::Geocoders::OSMGeocoder.geocode(@address)
-    assert_equal "county", res.accuracy
+    url = "#{@base_url}?format=json&polygon=0&addressdetails=1&q=#{escape(@address)}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    res = geocode(@address)
+    assert_equal 'county', res.accuracy
   end
 
   def test_osm_city_with_geo_loc
     response = MockSuccess.new
     response.expects(:body).returns(OSM_CITY)
-    url = "http://nominatim.openstreetmap.org/search?format=json&polygon=0&addressdetails=1&q=#{Geokit::Inflector.url_escape(@address)}"
-    Geokit::Geocoders::OSMGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    do_city_assertions(Geokit::Geocoders::OSMGeocoder.geocode(@osm_city_loc))
+    url = "#{@base_url}?format=json&polygon=0&addressdetails=1&q=#{escape(@address)}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    do_city_assertions(geocode(@osm_city_loc))
   end
 
   def test_reverse_geo_coding
     response = MockSuccess.new
     response.expects(:body).returns(OSM_REVERSE_PRILEP)
     prilep = Geokit::GeoLoc.new
-    prilep.lat, prilep.lng = "41.3527177", "21.5497808"
-    url = "http://nominatim.openstreetmap.org/reverse?format=json&addressdetails=1&lat=#{prilep.lat}&lon=#{prilep.lng}"
-    Geokit::Geocoders::OSMGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    res = Geokit::Geocoders::OSMGeocoder.do_reverse_geocode(prilep.ll)
+    prilep.lat, prilep.lng = '41.3527177', '21.5497808'
+    url = "#{@reverse_url}?format=json&addressdetails=1&lat=#{prilep.lat}&lon=#{prilep.lng}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    res = reverse_geocode(prilep.ll)
 
       # OSM does not return the exast lat lng in response
       # assert_equal prilep.lat.to_s.slice(1..5), res.lat.to_s.slice(1..5)
       # assert_equal prilep.lng.to_s.slice(1..5), res.lng.to_s.slice(1..5)
-      assert_equal "MK", res.country_code
-      assert_equal "osm", res.provider
+      assert_equal 'MK', res.country_code
+      assert_equal 'osm', res.provider
 
-      assert_equal "Prilep", res.city
+      assert_equal 'Prilep', res.city
       assert_nil res.state
 
-      assert_equal "Macedonia", res.country
+      assert_equal 'Macedonia', res.country
       assert_nil res.precision
       assert_equal true, res.success
 
-      assert_equal "Marksova, Prilep, MK", res.full_address
-      assert_equal "Marksova", res.street_address
+      assert_equal 'Marksova, Prilep, MK', res.full_address
+      assert_equal 'Marksova', res.street_address
   end
 
   def test_reverse_geo_code
@@ -116,23 +118,23 @@ class OSMGeocoderTest < BaseGeocoderTest #:nodoc: all
     response.expects(:body).returns(OSM_REVERSE_MADRID)
     location = Geokit::GeoLoc.new
     # Madrid
-    location.lat, location.lng = "40.4167413", "-3.7032498"
-    url = "http://nominatim.openstreetmap.org/reverse?format=json&addressdetails=1&lat=#{location.lat}&lon=#{location.lng}"
-    Geokit::Geocoders::OSMGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    res = Geokit::Geocoders::OSMGeocoder.do_reverse_geocode(location.ll)
+    location.lat, location.lng = '40.4167413', '-3.7032498'
+    url = "#{@reverse_url}?format=json&addressdetails=1&lat=#{location.lat}&lon=#{location.lng}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    res = reverse_geocode(location.ll)
 
-    assert_equal "ES", res.country_code
-    assert_equal "osm", res.provider
+    assert_equal 'ES', res.country_code
+    assert_equal 'osm', res.provider
 
-    assert_equal "Madrid", res.city
-    assert_equal "Madrid", res.state
+    assert_equal 'Madrid', res.city
+    assert_equal 'Madrid', res.state
 
-    assert_equal "Spain", res.country
+    assert_equal 'Spain', res.country
     assert_equal true, res.success
 
-    assert_equal "Calle Del Doctor Tolosa Latour, Usera, Madrid, Madrid, 28026, ES", res.full_address
-    assert_equal "28026", res.zip
-    assert_equal "Calle Del Doctor Tolosa Latour", res.street_address
+    assert_equal 'Calle Del Doctor Tolosa Latour, Usera, Madrid, Madrid, 28026, ES', res.full_address
+    assert_equal '28026', res.zip
+    assert_equal 'Calle Del Doctor Tolosa Latour', res.street_address
   end
 
   def test_reverse_geo_code_with_accept_language
@@ -140,38 +142,38 @@ class OSMGeocoderTest < BaseGeocoderTest #:nodoc: all
     response.expects(:body).returns(OSM_REVERSE_MADRID)
     location = Geokit::GeoLoc.new
     # Madrid
-    location.lat, location.lng = "40.4167413", "-3.7032498"
-    url = "http://nominatim.openstreetmap.org/reverse?format=json&addressdetails=1&lat=#{location.lat}&lon=#{location.lng}&accept-language=pt-br"
-    Geokit::Geocoders::OSMGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    Geokit::Geocoders::OSMGeocoder.do_reverse_geocode(location.ll, {:'accept-language' => "pt-br"})
+    location.lat, location.lng = '40.4167413', '-3.7032498'
+    url = "#{@reverse_url}?format=json&addressdetails=1&lat=#{location.lat}&lon=#{location.lng}&accept-language=pt-br"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    reverse_geocode(location.ll, {:'accept-language' => 'pt-br'})
   end
 
   def test_service_unavailable
     response = MockFailure.new
-    url = "http://nominatim.openstreetmap.org/search?format=json&polygon=0&addressdetails=1&q=#{Geokit::Inflector.url_escape(@address)}"
-    Geokit::Geocoders::OSMGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    assert !Geokit::Geocoders::OSMGeocoder.geocode(@osm_city_loc).success
+    url = "#{@base_url}?format=json&polygon=0&addressdetails=1&q=#{escape(@address)}"
+    geocoder_class.expects(:call_geocoder_service).with(url).returns(response)
+    assert !geocode(@osm_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 "California", res.state
-    assert_equal "San Francisco", res.city
-    assert_equal "37.792391,-122.394024", res.ll
+    assert_equal 'California', res.state
+    assert_equal 'San Francisco', res.city
+    assert_equal '37.792391,-122.394024', res.ll
     assert res.is_us?
-    assert_equal "Spear Street 100, San Francisco, California, 94105, US", res.full_address
-    assert_equal "osm", res.provider
+    assert_equal 'Spear Street 100, San Francisco, California, 94105, US', res.full_address
+    assert_equal 'osm', res.provider
   end
 
   def do_city_assertions(res)
-    assert_equal "California", res.state
-    assert_equal "San Francisco", res.city
-    assert_equal "37.7340974,-122.3912596", res.ll
+    assert_equal 'California', res.state
+    assert_equal 'San Francisco', res.city
+    assert_equal '37.7340974,-122.3912596', res.ll
     assert res.is_us?
-    assert_equal "San Francisco, California, US", res.full_address
+    assert_equal 'San Francisco, California, US', res.full_address
     assert_nil res.street_address
-    assert_equal "osm", res.provider
+    assert_equal 'osm', res.provider
   end
 end