graticule 1.0.0.pre2 → 2.0.0

data/test/graticule/geocoder/geocoder_us_test.rb

@@ -1,43 +0,0 @@
-require 'test_helper'
-
-module Graticule
-  module Geocoder
-    class GeocoderUsTest < Test::Unit::TestCase
-
-      def setup
-        URI::HTTP.responses = []
-        URI::HTTP.uris = []
-
-        @geocoder = GeocoderUs.new
-        @location = Location.new(
-          :street => "1600 Pennsylvania Ave NW, Washington DC 20502",
-          :longitude => -77.037684,
-          :latitude => 38.898748
-        )
-      end
-
-      def test_success
-        prepare_response(:success)
-        assert_equal @location, @geocoder.locate('1600 Pennsylvania Ave, Washington DC')
-      end
-    
-      def test_url
-        prepare_response(:success)
-        @geocoder.locate('1600 Pennsylvania Ave, Washington DC')
-        assert_equal 'http://rpc.geocoder.us/service/rest/geocode?address=1600%20Pennsylvania%20Ave,%20Washington%20DC',
-                     URI::HTTP.uris.first
-      end
-
-      def test_locate_bad_address
-        prepare_response(:unknown)
-        assert_raises(AddressError) { @geocoder.locate('yuck') }
-      end
-
-    protected
-      def prepare_response(id)
-        URI::HTTP.responses << response('geocoder_us', id)
-      end
-
-    end
-  end
-end

data/test/graticule/geocoder/geocoders.rb

@@ -1,55 +0,0 @@
-require 'test_helper'
-
-module Graticule
-  
-  # Generic tests for all geocoders (theoretically)
-  module GeocodersTestCase
-    
-    def test_success
-      return unless prepare_response(:success)
-      
-      location = Location.new(
-        :street => "1600 Amphitheatre Pkwy",
-        :city => "Mountain View",
-        :state => "CA",
-        :zip => "94043",
-        :country => "US",
-        :longitude => -122.083739,
-        :latitude => 37.423021,
-        :precision => :address
-      )
-      assert_equal location, @geocoder.locate('1600 Amphitheatre Parkway, Mountain View, CA')
-    end
-    
-    def test_bad_key
-      return unless prepare_response(:badkey)
-      assert_raises(CredentialsError) { @geocoder.locate('x') }
-    end
-    
-    def test_locate_missing_address
-      return unless prepare_response(:missing_address)
-      assert_raises(AddressError) { @geocoder.locate 'x' }
-    end
-    
-    def test_locate_server_error
-      return unless prepare_response(:server_error)
-      assert_raises(Error) { @geocoder.locate 'x' }
-    end
-
-    def test_locate_too_many_queries
-      return unless prepare_response(:limit)
-      assert_raises(CredentialsError) { @geocoder.locate 'x' }
-    end
-
-    def test_locate_unavailable_address
-      return unless prepare_response(:unavailable)
-      assert_raises(AddressError) { @geocoder.locate 'x' }
-    end
-
-    def test_locate_unknown_address
-      return unless prepare_response(:unknown_address)
-      assert_raises(AddressError) { @geocoder.locate 'x' }
-    end
-
-  end
-end

data/test/graticule/geocoder/geonames_test.rb

@@ -1,48 +0,0 @@
-require 'test_helper'
-
-module Graticule
-  module Geocoder
-    class GeonamesTest < Test::Unit::TestCase
-      def setup
-        URI::HTTP.responses = []
-        URI::HTTP.uris = []
-        @geocoder = Geonames.new
-      end
-
-      def test_time_zone
-        return unless prepare_response(:success)
-        
-        chicago = Location.new(:latitude => 41.85, :longitude => -87.65)
-        assert_equal 'America/Chicago', @geocoder.time_zone(chicago)
-        
-      end
-          
-      # def test_locate_server_error
-      #   return unless prepare_response(:server_error)
-      #   assert_raises(Error) { @geocoder.locate 'x' }
-      # end
-      # 
-      # def test_locate_too_many_queries
-      #   return unless prepare_response(:limit)
-      #   assert_raises(CredentialsError) { @geocoder.locate 'x' }
-      # end
-      # 
-      # def test_locate_unavailable_address
-      #   return unless prepare_response(:unavailable)
-      #   assert_raises(AddressError) { @geocoder.locate 'x' }
-      # end
-      # 
-      # def test_locate_unknown_address
-      #   return unless prepare_response(:unknown_address)
-      #   assert_raises(AddressError) { @geocoder.locate 'x' }
-      # end
-
-    protected
-
-      def prepare_response(id = :success)
-        URI::HTTP.responses << response('geonames', id)
-      end
-  
-    end
-  end
-end

data/test/graticule/geocoder/google_test.rb

@@ -1,107 +0,0 @@
-require 'test_helper'
-
-module Graticule
-  module Geocoder
-    class GoogleTest < Test::Unit::TestCase
-      def setup
-        URI::HTTP.responses = []
-        URI::HTTP.uris = []
-        @geocoder = Google.new('APP_ID')
-      end
-      
-      def test_success
-        return unless prepare_response(:success)
-        
-        location = Location.new(
-          :street => "1600 Amphitheatre Pkwy",
-          :locality => "Mountain View",
-          :region => "CA",
-          :postal_code => "94043",
-          :country => "US",
-          :longitude => -122.0850350,
-          :latitude => 37.4231390,
-          :precision => :address
-        )
-        assert_equal location, @geocoder.locate('1600 Amphitheatre Parkway, Mountain View, CA')
-      end
-      
-      # The #locate parameters are broad, so the XML response contains 
-      # multiple results at street-level precision. We expect to get the 
-      # first result back, and it should not contain a postal code.
-      def test_success_multiple_results
-        return unless prepare_response(:success_multiple_results)
-
-        location = Location.new(
-          :street => "Queen St W",
-          :locality => "Toronto",
-          :region => "ON",
-          :postal_code => nil,
-          :country => "CA",
-          :longitude => -79.4125590,
-          :latitude => 43.6455030,
-          :precision => :street
-        )
-        assert_equal location, @geocoder.locate('Queen St West, Toronto, ON CA')
-      end
-      
-      def test_only_coordinates
-        return unless prepare_response(:only_coordinates)
-        
-        location = Location.new(:longitude => -17.000000, :latitude => 15.000000)
-        assert_equal location, @geocoder.locate('15-17 & 16 Railroad Square, Nashua, NH, 03064')
-      end
-      
-      def test_partial
-        return unless prepare_response(:partial)
-        
-        location = Location.new(
-          :locality => "San Francisco",
-          :region => "CA",
-          :country => "US",
-          :longitude => -122.419209,
-          :latitude => 37.775206,
-          :precision => :locality
-        )
-        
-        assert_equal location, @geocoder.locate('sf ca')
-      end
-    
-      def test_locate_missing_address
-        return unless prepare_response(:missing_address)
-        assert_raises(AddressError) { @geocoder.locate 'x' }
-      end
-    
-      def test_locate_server_error
-        return unless prepare_response(:server_error)
-        assert_raises(Error) { @geocoder.locate 'x' }
-      end
-
-      def test_locate_too_many_queries
-        return unless prepare_response(:limit)
-        assert_raises(CredentialsError) { @geocoder.locate 'x' }
-      end
-
-      def test_locate_unavailable_address
-        return unless prepare_response(:unavailable)
-        assert_raises(AddressError) { @geocoder.locate 'x' }
-      end
-
-      def test_locate_unknown_address
-        return unless prepare_response(:unknown_address)
-        assert_raises(AddressError) { @geocoder.locate 'x' }
-      end
-      
-      def test_bad_key
-        return unless prepare_response(:badkey)
-        assert_raises(CredentialsError) { @geocoder.locate('x') }
-      end
-
-    protected
-
-      def prepare_response(id = :success)
-        URI::HTTP.responses << response('google', id)
-      end
-  
-    end
-  end
-end

data/test/graticule/geocoder/host_ip_test.rb

@@ -1,40 +0,0 @@
-require 'test_helper'
-
-module Graticule
-  module Geocoder
-    class HostIpTest < Test::Unit::TestCase
-      
-      def setup
-        @geocoder = HostIp.new
-        URI::HTTP.responses = []
-        URI::HTTP.uris = []
-      end
-      
-      def test_success
-        prepare_response :success
-        
-        location = Location.new :country => 'US', :locality => 'Mountain View',
-          :region => 'CA', :latitude => 37.402, :longitude => -122.078
-        
-        assert_equal location, @geocoder.locate('64.233.167.99')
-      end
-      
-      def test_unknown
-        prepare_response :unknown
-        assert_raises(AddressError) { @geocoder.locate('127.0.0.1') }
-      end
-
-      def test_private_ip
-        prepare_response :private
-        assert_raises(AddressError) { @geocoder.locate('127.0.0.1') }
-      end
-      
-    private
-    
-      def prepare_response(id = :success)
-        URI::HTTP.responses << response('host_ip', id, 'txt')
-      end
-      
-    end
-  end
-end

data/test/graticule/geocoder/local_search_maps_test.rb

@@ -1,30 +0,0 @@
-require 'test_helper'
-
-module Graticule
-  module Geocoder
-    class LocalSearchMapsTest < Test::Unit::TestCase
-      
-      def setup
-        @geocoder = LocalSearchMaps.new
-        URI::HTTP.responses = []
-        URI::HTTP.uris = []
-      end
-      
-      def test_success
-        prepare_response :success
-        
-        location = Location.new :latitude => 51.510036, :longitude => -0.130427
-        
-        assert_equal location, @geocoder.locate(:street => '48 Leicester Square',
-          :locality => 'London', :country => 'UK')
-      end
-
-    private
-    
-      def prepare_response(id = :success)
-        URI::HTTP.responses << response('local_search_maps', id, 'txt')
-      end
-      
-    end
-  end
-end

data/test/graticule/geocoder/mapquest_test.rb

@@ -1,49 +0,0 @@
-require 'test_helper'
-
-module Graticule
-  module Geocoder
-    class MapquestTest < Test::Unit::TestCase
-      def setup
-        URI::HTTP.responses = []
-        URI::HTTP.uris = []
-        @geocoder = Mapquest.new('client_id', 'password')
-      end
-
-      def test_success
-        prepare_response(:success)
-        location = Location.new(
-          :country => "US",
-          :latitude => 44.152019,
-          :locality => "Lovell",
-          :longitude => -70.892706,
-          :postal_code => "04051-3919",
-          :precision => :address,
-          :region => "ME",
-          :street => "44 Allen Rd"
-        )
-        assert_equal(location, @geocoder.locate('44 Allen Rd., Lovell, ME 04051'))
-      end
-
-      def test_multi_result
-        prepare_response(:multi_result)
-        location = Location.new(
-          :country => "US",
-          :latitude => 40.925598,
-          :locality => "Stony Brook",
-          :longitude => -73.141403,
-          :postal_code => nil,
-          :precision => :locality,
-          :region => "NY",
-          :street => nil
-        )
-        assert_equal(location, @geocoder.locate('217 Union St., NY'))
-      end
-
-      protected
-      
-      def prepare_response(id)
-        URI::HTTP.responses << response('mapquest', id)
-      end
-    end
-  end
-end

data/test/graticule/geocoder/multi_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-module Graticule
-  module Geocoder
-    class MultiTest < Test::Unit::TestCase
-
-      def setup
-        @mock_geocoders = [mock("geocoder 1"), mock("geocoder 2")]
-        @mock_geocoders.each {|g| g.stubs(:locate) }
-        @geocoder = Multi.new(*@mock_geocoders)
-      end
-
-      def test_locate_calls_each_geocoder_and_raises_error
-        @mock_geocoders.each do |g|
-          g.expects(:locate).with('test').raises(Graticule::AddressError)
-        end
-        assert_raises(Graticule::AddressError) { @geocoder.locate 'test' }
-      end
-
-      def test_locate_returns_first_result_without_calling_others
-        result = mock("result")
-        @mock_geocoders.first.expects(:locate).returns(result)
-        @mock_geocoders.last.expects(:locate).never
-        assert_equal result, @geocoder.locate('test')
-      end
-      
-      def test_locate_with_custom_block
-        @mock_geocoders.first.expects(:locate).returns(1)
-        @mock_geocoders.last.expects(:locate).returns(2)
-        @geocoder = Multi.new(*@mock_geocoders) {|r| r == 2 }
-        assert_equal 2, @geocoder.locate('test')
-      end
-
-      def test_locate_with_custom_block_and_no_match
-        @mock_geocoders.first.expects(:locate).returns(1)
-        @mock_geocoders.last.expects(:locate).returns(2)
-        @geocoder = Multi.new(*@mock_geocoders) {|r| r == 3 }
-        assert_raises(Graticule::AddressError) { @geocoder.locate('test') }
-      end
-      
-      def test_timeout
-        @mock = @mock_geocoders.first
-        def @mock.locate(*x)
-          sleep 1
-        end
-        @geocoder = Multi.new(@mock, :timeout => 0.1)
-        assert_raise(Timeout::Error) { @geocoder.locate('foo') }
-      end
-    end
-  end
-end

data/test/graticule/geocoder/multimap_test.rb

@@ -1,52 +0,0 @@
-require 'test_helper'
-
-module Graticule
-  module Geocoder
-    class MultimapTest < Test::Unit::TestCase
-
-      def setup
-        URI::HTTP.responses = []
-        URI::HTTP.uris = []
-        @geocoder = Multimap.new 'API_KEY'
-        @location = Location.new(
-          :street => "Oxford Street",
-          :locality => "LONDON",
-          :postal_code => "W1",
-          :country => "GB",
-          :longitude => -0.14839,
-          :latitude => 51.51452,
-          :precision => :address
-        )
-      end
-
-    def test_locate
-      prepare_response(:success)
-      assert_equal @location, @geocoder.locate('Oxford Street, LONDON, W1')
-    end
-
-    def test_url_from_string
-      prepare_response(:success)
-      @geocoder.locate('Oxford Street, LONDON, W1')
-      assert_equal 'http://clients.multimap.com/API/geocode/1.2/API_KEY?qs=Oxford%20Street,%20LONDON,%20W1', URI::HTTP.uris.first
-    end
-    
-    def test_url_from_location
-      prepare_response(:success)
-      @geocoder.locate(:street => 'Oxford Street', :locality => 'London')
-      assert_equal 'http://clients.multimap.com/API/geocode/1.2/API_KEY?city=London&countryCode=&postalCode=&region=&street=Oxford%20Street', URI::HTTP.uris.first
-    end
-
-
-    def test_locate_bad_address
-      prepare_response(:no_matches)
-      assert_raise(Error) { @geocoder.locate('yucksthoeusthaoeusnhtaosu') }
-    end
-
-    protected
-      def prepare_response(id)
-        URI::HTTP.responses << response('multimap', id)
-      end
-
-    end
-  end
-end