geocoder 1.2.6 → 1.6.1

data/test/unit/calculations_test.rb

@@ -1,220 +0,0 @@
-# encoding: utf-8
-$: << File.join(File.dirname(__FILE__), "..")
-require 'test_helper'
-
-class CalculationsTest < GeocoderTestCase
-  def setup
-    Geocoder.configure(
-      :units => :mi,
-      :distances => :linear
-    )
-  end
-
-  # --- degree distance ---
-
-  def test_longitude_degree_distance_at_equator
-    assert_equal 69, Geocoder::Calculations.longitude_degree_distance(0).round
-  end
-
-  def test_longitude_degree_distance_at_new_york
-    assert_equal 53, Geocoder::Calculations.longitude_degree_distance(40).round
-  end
-
-  def test_longitude_degree_distance_at_north_pole
-    assert_equal 0, Geocoder::Calculations.longitude_degree_distance(89.98).round
-  end
-
-
-  # --- distance between ---
-
-  def test_distance_between_in_miles
-    assert_equal 69, Geocoder::Calculations.distance_between([0,0], [0,1]).round
-    la_to_ny = Geocoder::Calculations.distance_between([34.05,-118.25], [40.72,-74]).round
-    assert (la_to_ny - 2444).abs < 10
-  end
-
-  def test_distance_between_in_kilometers
-    assert_equal 111, Geocoder::Calculations.distance_between([0,0], [0,1], :units => :km).round
-    la_to_ny = Geocoder::Calculations.distance_between([34.05,-118.25], [40.72,-74], :units => :km).round
-    assert (la_to_ny - 3942).abs < 10
-  end
-
-  def test_distance_between_in_nautical_miles
-    assert_equal 60, Geocoder::Calculations.distance_between([0,0], [0,1], :units => :nm).round
-    la_to_ny = Geocoder::Calculations.distance_between([34.05,-118.25], [40.72,-74], :units => :nm).round
-    assert (la_to_ny - 2124).abs < 10
-  end
-
-
-  # --- geographic center ---
-
-  def test_geographic_center_with_arrays
-    assert_equal [0.0, 0.5],
-      Geocoder::Calculations.geographic_center([[0,0], [0,1]])
-    assert_equal [0.0, 1.0],
-      Geocoder::Calculations.geographic_center([[0,0], [0,1], [0,2]])
-  end
-
-  def test_geographic_center_with_mixed_arguments
-    p1 = [0, 0]
-    p2 = PlaceReverseGeocoded.new("Some Cold Place", 0, 1)
-    assert_equal [0.0, 0.5], Geocoder::Calculations.geographic_center([p1, p2])
-  end
-
-
-  # --- bounding box ---
-
-  def test_bounding_box_calculation_in_miles
-    center = [51, 7] # Cologne, DE
-    radius = 10 # miles
-    corners = [50.86, 6.77, 51.14, 7.23]
-    assert_equal corners.map{ |i| (i * 100).round },
-      Geocoder::Calculations.bounding_box(center, radius).map{ |i| (i * 100).round }
-  end
-
-  def test_bounding_box_calculation_in_kilometers
-    center = [51, 7] # Cologne, DE
-    radius = 111 # kilometers (= 1 degree latitude)
-    corners = [50, 5.41, 52, 8.59]
-    assert_equal corners.map{ |i| (i * 100).round },
-      Geocoder::Calculations.bounding_box(center, radius, :units => :km).map{ |i| (i * 100).round }
-  end
-
-  def test_bounding_box_calculation_with_object
-    center = [51, 7] # Cologne, DE
-    radius = 10 # miles
-    corners = [50.86, 6.77, 51.14, 7.23]
-    obj = PlaceReverseGeocoded.new("Cologne", center[0], center[1])
-    assert_equal corners.map{ |i| (i * 100).round },
-      Geocoder::Calculations.bounding_box(obj, radius).map{ |i| (i * 100).round }
-  end
-
-  def test_bounding_box_calculation_with_address_string
-    assert_nothing_raised do
-      Geocoder::Calculations.bounding_box("4893 Clay St, San Francisco, CA", 50)
-    end
-  end
-
-  # --- random point ---
-
-  def test_random_point_within_radius
-    20.times do
-      center = [51, 7] # Cologne, DE
-      radius = 10 # miles
-      random_point = Geocoder::Calculations.random_point_near(center, radius)
-      distance = Geocoder::Calculations.distance_between(center, random_point)
-      assert distance <= radius
-    end
-  end
-
-  # --- bearing ---
-
-  def test_compass_points
-    assert_equal "N",  Geocoder::Calculations.compass_point(0)
-    assert_equal "N",  Geocoder::Calculations.compass_point(1.0)
-    assert_equal "N",  Geocoder::Calculations.compass_point(360)
-    assert_equal "N",  Geocoder::Calculations.compass_point(361)
-    assert_equal "N",  Geocoder::Calculations.compass_point(-22)
-    assert_equal "NW", Geocoder::Calculations.compass_point(-23)
-    assert_equal "S",  Geocoder::Calculations.compass_point(180)
-    assert_equal "S",  Geocoder::Calculations.compass_point(181)
-  end
-
-  def test_bearing_between
-    bearings = {
-      :n => 0,
-      :e => 90,
-      :s => 180,
-      :w => 270
-    }
-    points = {
-      :n => [41, -75],
-      :e => [40, -74],
-      :s => [39, -75],
-      :w => [40, -76]
-    }
-    directions = [:n, :e, :s, :w]
-    methods = [:linear, :spherical]
-
-    methods.each do |m|
-      directions.each_with_index do |d,i|
-        opp = directions[(i + 2) % 4] # opposite direction
-        b = Geocoder::Calculations.bearing_between(
-          points[d], points[opp], :method => m)
-        assert (b - bearings[opp]).abs < 1,
-          "Bearing (#{m}) should be close to #{bearings[opp]} but was #{b}."
-      end
-    end
-  end
-
-  def test_spherical_bearing_to
-    l = PlaceReverseGeocoded.new(*reverse_geocoded_object_params(:msg))
-    assert_equal 324, l.bearing_to([50,-85], :method => :spherical).round
-  end
-
-  def test_spherical_bearing_from
-    l = PlaceReverseGeocoded.new(*reverse_geocoded_object_params(:msg))
-    assert_equal 136, l.bearing_from([50,-85], :method => :spherical).round
-  end
-
-  def test_linear_bearing_from_and_to_are_exactly_opposite
-    l = PlaceReverseGeocoded.new(*reverse_geocoded_object_params(:msg))
-    assert_equal l.bearing_from([50,-86.1]), l.bearing_to([50,-86.1]) - 180
-  end
-
-  def test_extract_coordinates
-    coords = [-23,47]
-    l = PlaceReverseGeocoded.new("Madagascar", coords[0], coords[1])
-    assert_equal coords, Geocoder::Calculations.extract_coordinates(l)
-    assert_equal coords, Geocoder::Calculations.extract_coordinates(coords)
-  end
-
-  def test_extract_nan_coordinates
-    result = Geocoder::Calculations.extract_coordinates([ nil, nil ])
-    assert_nan_coordinates?(result)
-
-    result = Geocoder::Calculations.extract_coordinates(nil)
-    assert_nan_coordinates?(result)
-
-    result = Geocoder::Calculations.extract_coordinates('')
-    assert_nan_coordinates?(result)
-
-    result = Geocoder::Calculations.extract_coordinates([ 'nix' ])
-    assert_nan_coordinates?(result)
-
-    o = Object.new
-    result = Geocoder::Calculations.extract_coordinates(o)
-    assert_nan_coordinates?(result)
-  end
-
-  def test_coordinates_present
-    assert Geocoder::Calculations.coordinates_present?(3.23)
-    assert !Geocoder::Calculations.coordinates_present?(nil)
-    assert !Geocoder::Calculations.coordinates_present?(Geocoder::Calculations::NAN)
-    assert !Geocoder::Calculations.coordinates_present?(3.23, nil)
-  end
-
-  private # ------------------------------------------------------------------
-
-  def assert_nan_coordinates?(value)
-    assert value.is_a?(Array) &&
-      value.size == 2 &&
-      value[0].nan? &&
-      value[1].nan?,
-      "Expected value to be [NaN, NaN] but was #{value}"
-  end
-
-  def test_endpoint
-    # test 5 time with random coordinates and headings
-    [0..5].each do |i|
-      rheading = [*0..359].sample
-      rdistance = [*0..100].sample
-      startpoint = [45.0906, 7.6596]
-      endpoint = Geocoder::Calculations.endpoint(startpoint, rheading, rdistance)
-      assert_in_delta rdistance, 
-        Geocoder::Calculations.distance_between(startpoint, endpoint, :method => :spherical), 1E-5
-      assert_in_delta rheading, 
-        Geocoder::Calculations.bearing_between(startpoint, endpoint, :method => :spherical), 1E-2
-    end
-  end
-end

data/test/unit/configuration_test.rb

@@ -1,55 +0,0 @@
-# encoding: utf-8
-$: << File.join(File.dirname(__FILE__), "..")
-require 'test_helper'
-
-class ConfigurationTest < GeocoderTestCase
-  def setup
-    Geocoder::Configuration.set_defaults
-  end
-
-  def test_exception_raised_on_bad_lookup_config
-    Geocoder.configure(:lookup => :stoopid)
-    assert_raises Geocoder::ConfigurationError do
-      Geocoder.search "something dumb"
-    end
-  end
-
-  def test_setting_with_class_method
-    Geocoder::Configuration.units = :test
-    assert_equal :test, Geocoder.config.units
-  end
-
-  def test_setting_with_configure_method
-    Geocoder.configure(:units => :test)
-    assert_equal :test, Geocoder.config.units
-  end
-
-  def test_config_for_lookup
-    Geocoder.configure(
-      :timeout => 5,
-      :api_key => "aaa",
-      :google => {
-        :timeout => 2
-      }
-    )
-    assert_equal 2, Geocoder.config_for_lookup(:google).timeout
-    assert_equal "aaa", Geocoder.config_for_lookup(:google).api_key
-  end
-
-  def test_configuration_chain
-    v = PlaceReverseGeocoded.new(*reverse_geocoded_object_params(:msg))
-    v.latitude  = 0
-    v.longitude = 0
-
-    # method option > global configuration
-    Geocoder.configure(:units => :km)
-    assert_equal 69, v.distance_to([0,1], :mi).round
-
-    # per-model configuration > global configuration
-    PlaceReverseGeocoded.reverse_geocoded_by :latitude, :longitude, method: :spherical, units: :mi
-    assert_equal 69, v.distance_to([0,1]).round
-
-    # method option > per-model configuration
-    assert_equal 111, v.distance_to([0,1], :km).round
-  end
-end

data/test/unit/error_handling_test.rb

@@ -1,56 +0,0 @@
-# encoding: utf-8
-$: << File.join(File.dirname(__FILE__), "..")
-require 'test_helper'
-
-class ErrorHandlingTest < GeocoderTestCase
-
-  def teardown
-    Geocoder.configure(:always_raise => [])
-  end
-
-  def test_does_not_choke_on_timeout
-    silence_warnings do
-      Geocoder::Lookup.all_services_except_test.each do |l|
-        Geocoder.configure(:lookup => l)
-        set_api_key!(l)
-        assert_nothing_raised { Geocoder.search("timeout") }
-      end
-    end
-  end
-
-  def test_always_raise_timeout_error
-    Geocoder.configure(:always_raise => [TimeoutError])
-    Geocoder::Lookup.all_services_except_test.each do |l|
-      next if l == :maxmind_local || l == :geoip2 # local, does not use cache
-      lookup = Geocoder::Lookup.get(l)
-      set_api_key!(l)
-      assert_raises TimeoutError do
-        lookup.send(:results, Geocoder::Query.new("timeout"))
-      end
-    end
-  end
-
-  def test_always_raise_socket_error
-    Geocoder.configure(:always_raise => [SocketError])
-    Geocoder::Lookup.all_services_except_test.each do |l|
-      next if l == :maxmind_local || l == :geoip2 # local, does not use cache
-      lookup = Geocoder::Lookup.get(l)
-      set_api_key!(l)
-      assert_raises SocketError do
-        lookup.send(:results, Geocoder::Query.new("socket_error"))
-      end
-    end
-  end
-
-  def test_always_raise_connection_refused_error
-    Geocoder.configure(:always_raise => [Errno::ECONNREFUSED])
-    Geocoder::Lookup.all_services_except_test.each do |l|
-      next if l == :maxmind_local || l == :geoip2 # local, does not use cache
-      lookup = Geocoder::Lookup.get(l)
-      set_api_key!(l)
-      assert_raises Errno::ECONNREFUSED do
-        lookup.send(:results, Geocoder::Query.new("connection_refused"))
-      end
-    end
-  end
-end

data/test/unit/geocoder_test.rb

@@ -1,78 +0,0 @@
-# encoding: utf-8
-$: << File.join(File.dirname(__FILE__), "..")
-require 'test_helper'
-
-class GeocoderTest < GeocoderTestCase
-
-  def test_distance_to_returns_float
-    v = Place.new(*geocoded_object_params(:msg))
-    v.latitude, v.longitude = [40.750354, -73.993371]
-    assert (v.distance_to([30, -94])).is_a?(Float)
-  end
-
-  def test_coordinates_method_returns_array
-    assert Geocoder.coordinates("Madison Square Garden, New York, NY").is_a?(Array)
-  end
-
-  def test_address_method_returns_string
-    assert Geocoder.address([40.750354, -73.993371]).is_a?(String)
-  end
-
-  def test_geographic_center_doesnt_overwrite_argument_value
-    # test for the presence of a bug that was introduced in version 0.9.11
-    orig_points = [[52,8], [46,9], [42,5]]
-    points = orig_points.clone
-    Geocoder::Calculations.geographic_center(points)
-    assert_equal orig_points, points
-  end
-
-  def test_geocode_assigns_and_returns_coordinates
-    v = Place.new(*geocoded_object_params(:msg))
-    coords = [40.750354, -73.993371]
-    assert_equal coords, v.geocode
-    assert_equal coords, [v.latitude, v.longitude]
-  end
-
-  def test_geocode_block_executed_when_no_results
-    v = PlaceWithCustomResultsHandling.new("Nowhere", "no results")
-    v.geocode
-    assert_equal "NOT FOUND", v.coords_string
-  end
-
-  def test_reverse_geocode_assigns_and_returns_address
-    v = PlaceReverseGeocoded.new(*reverse_geocoded_object_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_forward_and_reverse_geocoding_on_same_model_works
-    g = PlaceWithForwardAndReverseGeocoding.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_geocode_with_custom_lookup_param
-    v = PlaceWithCustomLookup.new(*geocoded_object_params(:msg))
-    v.geocode
-    assert_equal Geocoder::Result::Nominatim, v.result_class
-  end
-
-  def test_geocode_with_custom_lookup_proc_param
-    v = PlaceWithCustomLookupProc.new(*geocoded_object_params(:msg))
-    v.geocode
-    assert_equal Geocoder::Result::Nominatim, v.result_class
-  end
-
-  def test_reverse_geocode_with_custom_lookup_param
-    v = PlaceReverseGeocodedWithCustomLookup.new(*reverse_geocoded_object_params(:msg))
-    v.reverse_geocode
-    assert_equal Geocoder::Result::Nominatim, v.result_class
-  end
-end

data/test/unit/https_test.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-$: << File.join(File.dirname(__FILE__), "..")
-require 'test_helper'
-
-class HttpsTest < GeocoderTestCase
-
-  def test_uses_https_for_secure_query
-    Geocoder.configure(:use_https => true)
-    g = Geocoder::Lookup::Google.new
-    assert_match(/^https:/, g.query_url(Geocoder::Query.new("test")))
-  end
-
-  def test_uses_http_by_default
-    g = Geocoder::Lookup::Google.new
-    assert_match(/^http:/, g.query_url(Geocoder::Query.new("test")))
-  end
-end

data/test/unit/ip_address_test.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-$: << File.join(File.dirname(__FILE__), "..")
-require 'test_helper'
-
-class IpAddressTest < GeocoderTestCase
-
-  def test_valid
-    assert Geocoder::IpAddress.new("232.65.123.94").valid?
-    assert Geocoder::IpAddress.new("666.65.123.94").valid? # technically invalid
-    assert Geocoder::IpAddress.new("::ffff:12.34.56.78").valid?
-    assert Geocoder::IpAddress.new("3ffe:0b00:0000:0000:0001:0000:0000:000a").valid?
-    assert Geocoder::IpAddress.new("::1").valid?
-    assert !Geocoder::IpAddress.new("232.65.123.94.43").valid?
-    assert !Geocoder::IpAddress.new("232.65.123").valid?
-    assert !Geocoder::IpAddress.new("::ffff:123.456.789").valid?
-    assert !Geocoder::IpAddress.new("Test\n232.65.123.94").valid?
-  end
-
-  def test_loopback
-    assert Geocoder::IpAddress.new("0.0.0.0").loopback?
-    assert Geocoder::IpAddress.new("127.0.0.1").loopback?
-    assert Geocoder::IpAddress.new("::1").loopback?
-    assert !Geocoder::IpAddress.new("232.65.123.234").loopback?
-    assert !Geocoder::IpAddress.new("127 Main St.").loopback?
-    assert !Geocoder::IpAddress.new("John Doe\n127 Main St.\nAnywhere, USA").loopback?
-  end
-end

data/test/unit/lookup_test.rb

@@ -1,153 +0,0 @@
-# encoding: utf-8
-$: << File.join(File.dirname(__FILE__), "..")
-require 'test_helper'
-
-class LookupTest < GeocoderTestCase
-
-  def test_responds_to_name_method
-    Geocoder::Lookup.all_services.each do |l|
-      lookup = Geocoder::Lookup.get(l)
-      assert lookup.respond_to?(:name),
-        "Lookup #{l} does not respond to #name method."
-    end
-  end
-
-  def test_search_returns_empty_array_when_no_results
-    Geocoder::Lookup.all_services_except_test.each do |l|
-      lookup = Geocoder::Lookup.get(l)
-      set_api_key!(l)
-      assert_equal [], lookup.send(:results, Geocoder::Query.new("no results")),
-        "Lookup #{l} does not return empty array when no results."
-    end
-  end
-
-  def test_query_url_contains_values_in_params_hash
-    Geocoder::Lookup.all_services_except_test.each do |l|
-      next if [:freegeoip, :maxmind_local, :telize, :pointpin, :geoip2].include? l # does not use query string
-      set_api_key!(l)
-      url = Geocoder::Lookup.get(l).query_url(Geocoder::Query.new(
-        "test", :params => {:one_in_the_hand => "two in the bush"}
-      ))
-      # should be "+"s for all lookups except Yahoo
-      assert_match(/one_in_the_hand=two(%20|\+)in(%20|\+)the(%20|\+)bush/, url,
-        "Lookup #{l} does not appear to support arbitrary params in URL")
-    end
-  end
-
-  {
-    :esri => :l,
-    :bing => :key,
-    :geocoder_ca => :auth,
-    :google => :language,
-    :google_premier => :language,
-    :mapquest => :key,
-    :maxmind => :l,
-    :nominatim => :"accept-language",
-    :yahoo => :locale,
-    :yandex => :plng
-  }.each do |l,p|
-    define_method "test_passing_param_to_#{l}_query_overrides_configuration_value" do
-      set_api_key!(l)
-      url = Geocoder::Lookup.get(l).query_url(Geocoder::Query.new(
-        "test", :params => {p => "xxxx"}
-      ))
-      assert_match(/#{p}=xxxx/, url,
-        "Param passed to #{l} lookup does not override configuration value")
-    end
-  end
-
-  {
-    :google => :language,
-    :google_premier => :language,
-    :nominatim => :"accept-language",
-    :yahoo => :locale,
-    :yandex => :plng
-  }.each do |l,p|
-    define_method "test_passing_language_to_#{l}_query_overrides_configuration_value" do
-      set_api_key!(l)
-      url = Geocoder::Lookup.get(l).query_url(Geocoder::Query.new(
-        "test", :language => 'xxxx'
-      ))
-      assert_match(/#{p}=xxxx/, url,
-        "Param passed to #{l} lookup does not override configuration value")
-    end
-  end
-
-  def test_raises_exception_on_invalid_key
-    Geocoder.configure(:always_raise => [Geocoder::InvalidApiKey])
-    #Geocoder::Lookup.all_services_except_test.each do |l|
-    [:bing, :yahoo, :yandex, :maxmind, :baidu, :baidu_ip].each do |l|
-      lookup = Geocoder::Lookup.get(l)
-      assert_raises Geocoder::InvalidApiKey do
-        lookup.send(:results, Geocoder::Query.new("invalid key"))
-      end
-    end
-  end
-
-  def test_returns_empty_array_on_invalid_key
-    silence_warnings do
-      #Geocoder::Lookup.all_services_except_test.each do |l|
-      [:bing, :yahoo, :yandex, :maxmind, :baidu, :baidu_ip].each do |l|
-        Geocoder.configure(:lookup => l)
-        set_api_key!(l)
-        assert_equal [], Geocoder.search("invalid key")
-      end
-    end
-  end
-
-  def test_does_not_choke_on_nil_address
-    Geocoder::Lookup.all_services.each do |l|
-      Geocoder.configure(:lookup => l)
-      assert_nothing_raised { Place.new("Place", nil).geocode }
-    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_baidu_api_key
-    Geocoder.configure(:api_key => "MY_KEY")
-    g = Geocoder::Lookup::BaiduIp.new
-    assert_match "ak=MY_KEY", g.query_url(Geocoder::Query.new("232.65.123.94"))
-  end
-
-  def test_baidu_ip_api_key
-    Geocoder.configure(:api_key => "MY_KEY")
-    g = Geocoder::Lookup::Baidu.new
-    assert_match "ak=MY_KEY", g.query_url(Geocoder::Query.new("Madison Square Garden, New York, NY  10001, United States"))
-  end
-
-  def test_pointpin_api_key
-    Geocoder.configure(:api_key => "MY_KEY")
-    g = Geocoder::Lookup::Pointpin.new
-    assert_match "/MY_KEY/", g.query_url(Geocoder::Query.new("232.65.123.94"))
-  end
-
-  def test_google_api_key
-    Geocoder.configure(:api_key => "MY_KEY")
-    g = Geocoder::Lookup::Google.new
-    assert_match "key=MY_KEY", g.query_url(Geocoder::Query.new("Madison Square Garden, New York, NY  10001, United States"))
-  end
-
-  def test_geocoder_ca_showpostal
-    Geocoder.configure(:api_key => "MY_KEY")
-    g = Geocoder::Lookup::GeocoderCa.new
-    assert_match "showpostal=1", g.query_url(Geocoder::Query.new("Madison Square Garden, New York, NY  10001, United States"))
-  end
-
-  def test_raises_configuration_error_on_missing_key
-    [:bing, :baidu].each do |l|
-      assert_raises Geocoder::ConfigurationError do
-        Geocoder.configure(:lookup => l, :api_key => nil)
-        Geocoder.search("Madison Square Garden, New York, NY  10001, United States")
-      end
-    end
-  end
-
-  def test_handle
-    assert_equal :google, Geocoder::Lookup::Google.new.handle
-    assert_equal :geocoder_ca, Geocoder::Lookup::GeocoderCa.new.handle
-  end
-end

data/test/unit/lookups/bing_test.rb

@@ -1,68 +0,0 @@
-# encoding: utf-8
-$: << File.join(File.dirname(__FILE__), "..", "..")
-require 'test_helper'
-
-class BingTest < GeocoderTestCase
-
-  def setup
-    Geocoder.configure(lookup: :bing)
-    set_api_key!(:bing)
-  end
-
-  def test_query_for_reverse_geocode
-    lookup = Geocoder::Lookup::Bing.new
-    url = lookup.query_url(Geocoder::Query.new([45.423733, -75.676333]))
-    assert_match(/Locations\/45.423733/, url)
-  end
-
-  def test_result_components
-    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_no_results
-    results = Geocoder.search("no results")
-    assert_equal 0, results.length
-  end
-
-  def test_query_url_contains_region
-    lookup = Geocoder::Lookup::Bing.new
-    url = lookup.query_url(Geocoder::Query.new(
-      "manchester",
-      :region => "uk"
-    ))
-    assert_match(/Locations\/uk\?q=manchester/, url)
-    assert_no_match(/query/, url)
-  end
-
-  def test_query_url_without_region
-    lookup = Geocoder::Lookup::Bing.new
-    url = lookup.query_url(Geocoder::Query.new(
-      "manchester"
-    ))
-    assert_match(/Locations\?q=manchester/, url)
-    assert_no_match(/query/, url)
-  end
-
-  def test_query_url_contains_address_with_spaces
-    lookup = Geocoder::Lookup::Bing.new
-    url = lookup.query_url(Geocoder::Query.new(
-      "manchester, lancashire",
-      :region => "uk"
-    ))
-    assert_match(/Locations\/uk\?q=manchester,%20lancashire/, url)
-    assert_no_match(/query/, url)
-  end
-
-  def test_query_url_contains_address_with_trailing_and_leading_spaces
-    lookup = Geocoder::Lookup::Bing.new
-    url = lookup.query_url(Geocoder::Query.new(
-      " manchester, lancashire ",
-      :region => "uk"
-    ))
-    assert_match(/Locations\/uk\?q=manchester,%20lancashire/, url)
-    assert_no_match(/query/, url)
-  end
-end