geocoder2 0.1.0

data/lib/hash_recursive_merge.rb

@@ -0,0 +1,74 @@
+# 
+# = Hash Recursive Merge
+# 
+# Merges a Ruby Hash recursively, Also known as deep merge.
+# Recursive version of Hash#merge and Hash#merge!.
+# 
+# Category::    Ruby
+# Package::     Hash
+# Author::      Simone Carletti <weppos@weppos.net>
+# Copyright::   2007-2008 The Authors
+# License::     MIT License
+# Link::        http://www.simonecarletti.com/
+# Source::      http://gist.github.com/gists/6391/
+#
+module HashRecursiveMerge
+
+  #
+  # Recursive version of Hash#merge!
+  # 
+  # Adds the contents of +other_hash+ to +hsh+, 
+  # merging entries in +hsh+ with duplicate keys with those from +other_hash+.
+  # 
+  # Compared with Hash#merge!, this method supports nested hashes.
+  # When both +hsh+ and +other_hash+ contains an entry with the same key,
+  # it merges and returns the values from both arrays.
+  # 
+  #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+  #    h2 = {"b" => 254, "c" => {"c1" => 16, "c3" => 94}}
+  #    h1.rmerge!(h2)   #=> {"a" => 100, "b" => 254, "c" => {"c1" => 16, "c2" => 14, "c3" => 94}}
+  #    
+  # Simply using Hash#merge! would return
+  # 
+  #    h1.merge!(h2)    #=> {"a" => 100, "b" = >254, "c" => {"c1" => 16, "c3" => 94}}
+  # 
+  def rmerge!(other_hash)
+    merge!(other_hash) do |key, oldval, newval|
+      oldval.class == self.class ? oldval.rmerge!(newval) : newval
+    end
+  end
+
+  #
+  # Recursive version of Hash#merge
+  # 
+  # Compared with Hash#merge!, this method supports nested hashes.
+  # When both +hsh+ and +other_hash+ contains an entry with the same key,
+  # it merges and returns the values from both arrays.
+  # 
+  # Compared with Hash#merge, this method provides a different approch
+  # for merging nasted hashes.
+  # If the value of a given key is an Hash and both +other_hash+ abd +hsh
+  # includes the same key, the value is merged instead replaced with
+  # +other_hash+ value.
+  # 
+  #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+  #    h2 = {"b" => 254, "c" => {"c1" => 16, "c3" => 94}}
+  #    h1.rmerge(h2)    #=> {"a" => 100, "b" => 254, "c" => {"c1" => 16, "c2" => 14, "c3" => 94}}
+  #    
+  # Simply using Hash#merge would return
+  # 
+  #    h1.merge(h2)     #=> {"a" => 100, "b" = >254, "c" => {"c1" => 16, "c3" => 94}}
+  # 
+  def rmerge(other_hash)
+    r = {}
+    merge(other_hash) do |key, oldval, newval|
+      r[key] = oldval.class == self.class ? oldval.rmerge(newval) : newval
+    end
+  end
+
+end
+
+
+class Hash
+  include HashRecursiveMerge
+end

data/lib/oauth_util.rb

@@ -0,0 +1,112 @@
+# A utility for signing an url using OAuth in a way that's convenient for debugging
+# Note: the standard Ruby OAuth lib is here http://github.com/mojodna/oauth
+# Source: http://gist.github.com/383159
+# License: http://gist.github.com/375593
+# Usage: see example.rb below
+#
+# NOTE: This file has been modified from the original Gist:
+#
+# 1. Fix to prevent param-array conversion, as mentioned in Gist comment.
+# 2. Query string escaping has been changed. See:
+#   https://github.com/alexreisner/geocoder2/pull/360
+#
+
+require 'uri'
+require 'cgi'
+require 'openssl'
+require 'base64'
+
+class OauthUtil
+
+  attr_accessor :consumer_key, :consumer_secret, :token, :token_secret, :req_method, 
+                :sig_method, :oauth_version, :callback_url, :params, :req_url, :base_str
+
+  def initialize
+    @consumer_key = ''
+    @consumer_secret = ''
+    @token = ''
+    @token_secret = ''
+    @req_method = 'GET'
+    @sig_method = 'HMAC-SHA1'
+    @oauth_version = '1.0'
+    @callback_url = ''
+  end
+
+  # openssl::random_bytes returns non-word chars, which need to be removed. using alt method to get length
+  # ref http://snippets.dzone.com/posts/show/491
+  def nonce
+    Array.new( 5 ) { rand(256) }.pack('C*').unpack('H*').first
+  end
+
+  def percent_encode( string )
+
+    # ref http://snippets.dzone.com/posts/show/1260
+    return URI.escape( string, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]") ).gsub('*', '%2A')
+  end
+
+  # @ref http://oauth.net/core/1.0/#rfc.section.9.2
+  def signature
+    key = percent_encode( @consumer_secret ) + '&' + percent_encode( @token_secret )
+
+    # ref: http://blog.nathanielbibler.com/post/63031273/openssl-hmac-vs-ruby-hmac-benchmarks
+    digest = OpenSSL::Digest::Digest.new( 'sha1' )
+    hmac = OpenSSL::HMAC.digest( digest, key, @base_str )
+
+    # ref http://groups.google.com/group/oauth-ruby/browse_thread/thread/9110ed8c8f3cae81
+    Base64.encode64( hmac ).chomp.gsub( /\n/, '' )
+  end
+
+  # sort (very important as it affects the signature), concat, and percent encode
+  # @ref http://oauth.net/core/1.0/#rfc.section.9.1.1
+  # @ref http://oauth.net/core/1.0/#9.2.1
+  # @ref http://oauth.net/core/1.0/#rfc.section.A.5.1
+  def query_string
+    pairs = []
+    @params.sort.each { | key, val | 
+      pairs.push( "#{ CGI.escape(key.to_s).gsub(/%(5B|5D)/n) { [$1].pack('H*') } }=#{ CGI.escape(val.to_s) }" )
+    }
+    pairs.join '&'
+  end
+
+  # organize params & create signature
+  def sign( parsed_url )
+
+    @params = {
+      'oauth_consumer_key' => @consumer_key,
+      'oauth_nonce' => nonce,
+      'oauth_signature_method' => @sig_method,
+      'oauth_timestamp' => Time.now.to_i.to_s,
+      'oauth_version' => @oauth_version
+    }
+
+    # if url has query, merge key/values into params obj overwriting defaults
+    if parsed_url.query
+      CGI.parse( parsed_url.query ).each do |k,v|
+        if v.is_a?(Array) && v.count == 1
+          @params[k] = v.first
+        else
+          @params[k] = v
+        end
+      end
+    end
+
+    # @ref http://oauth.net/core/1.0/#rfc.section.9.1.2
+    @req_url = parsed_url.scheme + '://' + parsed_url.host + parsed_url.path
+
+    # create base str. make it an object attr for ez debugging
+    # ref http://oauth.net/core/1.0/#anchor14
+    @base_str = [ 
+      @req_method, 
+      percent_encode( req_url ), 
+
+      # normalization is just x-www-form-urlencoded
+      percent_encode( query_string ) 
+
+    ].join( '&' )
+
+    # add signature
+    @params[ 'oauth_signature' ] = signature
+
+    return self
+  end
+end

data/lib/tasks/geocoder2.rake

@@ -0,0 +1,27 @@
+namespace :geocode do
+  desc "Geocode all objects without coordinates."
+  task :all => :environment do
+    class_name = ENV['CLASS'] || ENV['class']
+    sleep_timer = ENV['SLEEP'] || ENV['sleep']
+    raise "Please specify a CLASS (model)" unless class_name
+    klass = class_from_string(class_name)
+
+    klass.not_geocoded.each do |obj|
+      obj.geocode; obj.save
+      sleep(sleep_timer.to_f) unless sleep_timer.nil?
+    end
+  end
+end
+
+##
+# Get a class object from the string given in the shell environment.
+# Similar to ActiveSupport's +constantize+ method.
+#
+def class_from_string(class_name)
+  parts = class_name.split("::")
+  constant = Object
+  parts.each do |part|
+    constant = constant.const_get(part)
+  end
+  constant
+end

data/test/active_record_test.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+require 'test_helper'
+
+class ActiveRecordTest < Test::Unit::TestCase
+
+  def test_exclude_condition_when_model_has_a_custom_primary_key
+    venue = VenuePlus.new(*venue_params(:msg))
+
+    # just call private method directly so we don't have to stub .near scope
+    conditions = venue.class.send(:add_exclude_condition, ["fake_condition"], venue)
+
+    assert_match( /#{VenuePlus.primary_key}/, conditions.join)
+  end
+
+end

data/test/cache_test.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+require 'test_helper'
+
+class CacheTest < Test::Unit::TestCase
+
+  def test_second_occurrence_of_request_is_cache_hit
+    Geocoder2.configure(:cache => {})
+    Geocoder2::Lookup.all_services_except_test.each do |l|
+      Geocoder2.configure(:lookup => l)
+      set_api_key!(l)
+      results = Geocoder2.search("Madison Square Garden")
+      assert !results.first.cache_hit,
+        "Lookup #{l} returned erroneously cached result."
+      results = Geocoder2.search("Madison Square Garden")
+      assert results.first.cache_hit,
+        "Lookup #{l} did not return cached result."
+    end
+  end
+
+  def test_google_over_query_limit_does_not_hit_cache
+    Geocoder2.configure(:cache => {})
+    Geocoder2.configure(:lookup => :google)
+    set_api_key!(:google)
+    Geocoder2.configure(:always_raise => :all)
+    assert_raises Geocoder2::OverQueryLimitError do
+      Geocoder2.search("over limit")
+    end
+    lookup = Geocoder2::Lookup.get(:google)
+    assert_equal false, lookup.instance_variable_get(:@cache_hit)
+    assert_raises Geocoder2::OverQueryLimitError do
+      Geocoder2.search("over limit")
+    end
+    assert_equal false, lookup.instance_variable_get(:@cache_hit)
+  end
+end

data/test/calculations_test.rb

@@ -0,0 +1,211 @@
+# encoding: utf-8
+require 'test_helper'
+
+class CalculationsTest < Test::Unit::TestCase
+  def setup
+    Geocoder2.configure(
+      :units => :mi,
+      :distances => :linear
+    )
+  end
+
+  # --- degree distance ---
+
+  def test_longitude_degree_distance_at_equator
+    assert_equal 69, Geocoder2::Calculations.longitude_degree_distance(0).round
+  end
+
+  def test_longitude_degree_distance_at_new_york
+    assert_equal 53, Geocoder2::Calculations.longitude_degree_distance(40).round
+  end
+
+  def test_longitude_degree_distance_at_north_pole
+    assert_equal 0, Geocoder2::Calculations.longitude_degree_distance(89.98).round
+  end
+
+
+  # --- distance between ---
+
+  def test_distance_between_in_miles
+    assert_equal 69, Geocoder2::Calculations.distance_between([0,0], [0,1]).round
+    la_to_ny = Geocoder2::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, Geocoder2::Calculations.distance_between([0,0], [0,1], :units => :km).round
+    la_to_ny = Geocoder2::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, Geocoder2::Calculations.distance_between([0,0], [0,1], :units => :nm).round
+    la_to_ny = Geocoder2::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],
+      Geocoder2::Calculations.geographic_center([[0,0], [0,1]])
+    assert_equal [0.0, 1.0],
+      Geocoder2::Calculations.geographic_center([[0,0], [0,1], [0,2]])
+  end
+
+  def test_geographic_center_with_mixed_arguments
+    p1 = [0, 0]
+    p2 = Landmark.new("Some Cold Place", 0, 1)
+    assert_equal [0.0, 0.5], Geocoder2::Calculations.geographic_center([p1, p2])
+  end
+
+
+  # --- bounding box ---
+
+  def test_bounding_box_calculation_in_miles
+    center = [51, 7] # Cologne, DE
+    radius = 10 # miles
+    dlon = radius / Geocoder2::Calculations.latitude_degree_distance
+    dlat = radius / Geocoder2::Calculations.longitude_degree_distance(center[0])
+    corners = [50.86, 6.77, 51.14, 7.23]
+    assert_equal corners.map{ |i| (i * 100).round },
+      Geocoder2::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)
+    dlon = radius / Geocoder2::Calculations.latitude_degree_distance(:km)
+    dlat = radius / Geocoder2::Calculations.longitude_degree_distance(center[0], :km)
+    corners = [50, 5.41, 52, 8.59]
+    assert_equal corners.map{ |i| (i * 100).round },
+      Geocoder2::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
+    dlon = radius / Geocoder2::Calculations.latitude_degree_distance
+    dlat = radius / Geocoder2::Calculations.longitude_degree_distance(center[0])
+    corners = [50.86, 6.77, 51.14, 7.23]
+    obj = Landmark.new("Cologne", center[0], center[1])
+    assert_equal corners.map{ |i| (i * 100).round },
+      Geocoder2::Calculations.bounding_box(obj, radius).map{ |i| (i * 100).round }
+  end
+
+  def test_bounding_box_calculation_with_address_string
+    assert_nothing_raised do
+      Geocoder2::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 = Geocoder2::Calculations.random_point_near(center, radius)
+      distance = Geocoder2::Calculations.distance_between(center, random_point)
+      assert distance <= radius
+    end
+  end
+
+  # --- bearing ---
+
+  def test_compass_points
+    assert_equal "N",  Geocoder2::Calculations.compass_point(0)
+    assert_equal "N",  Geocoder2::Calculations.compass_point(1.0)
+    assert_equal "N",  Geocoder2::Calculations.compass_point(360)
+    assert_equal "N",  Geocoder2::Calculations.compass_point(361)
+    assert_equal "N",  Geocoder2::Calculations.compass_point(-22)
+    assert_equal "NW", Geocoder2::Calculations.compass_point(-23)
+    assert_equal "S",  Geocoder2::Calculations.compass_point(180)
+    assert_equal "S",  Geocoder2::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 = Geocoder2::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 = Landmark.new(*landmark_params(:msg))
+    assert_equal 324, l.bearing_to([50,-85], :method => :spherical).round
+  end
+
+  def test_spherical_bearing_from
+    l = Landmark.new(*landmark_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 = Landmark.new(*landmark_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 = Landmark.new("Madagascar", coords[0], coords[1])
+    assert_equal coords, Geocoder2::Calculations.extract_coordinates(l)
+    assert_equal coords, Geocoder2::Calculations.extract_coordinates(coords)
+  end
+
+  def test_extract_nan_coordinates
+    result = Geocoder2::Calculations.extract_coordinates([ nil, nil ])
+    assert_nan_coordinates?(result)
+
+    result = Geocoder2::Calculations.extract_coordinates(nil)
+    assert_nan_coordinates?(result)
+
+    result = Geocoder2::Calculations.extract_coordinates('')
+    assert_nan_coordinates?(result)
+
+    result = Geocoder2::Calculations.extract_coordinates([ 'nix' ])
+    assert_nan_coordinates?(result)
+
+    o = Object.new
+    result = Geocoder2::Calculations.extract_coordinates(o)
+    assert_nan_coordinates?(result)
+  end
+
+  def test_coordinates_present
+    assert Geocoder2::Calculations.coordinates_present?(3.23)
+    assert !Geocoder2::Calculations.coordinates_present?(nil)
+    assert !Geocoder2::Calculations.coordinates_present?(Geocoder2::Calculations::NAN)
+    assert !Geocoder2::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
+end

data/test/configuration_test.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+require 'test_helper'
+
+class ConfigurationTest < Test::Unit::TestCase
+  def setup
+    Geocoder2::Configuration.set_defaults
+  end
+
+  def test_exception_raised_on_bad_lookup_config
+    Geocoder2.configure(:lookup => :stoopid)
+    assert_raises Geocoder2::ConfigurationError do
+      Geocoder2.search "something dumb"
+    end
+  end
+
+  def test_setting_with_class_method
+    Geocoder2::Configuration.units = :test
+    assert_equal :test, Geocoder2.config.units
+  end
+
+  def test_setting_with_configure_method
+    Geocoder2.configure(:units => :test)
+    assert_equal :test, Geocoder2.config.units
+  end
+
+  def test_setting_with_block_syntax
+    orig = $VERBOSE; $VERBOSE = nil
+    Geocoder2.configure do |config|
+      config.units = :test
+    end
+    assert_equal :test, Geocoder2.config.units
+  ensure
+    $VERBOSE = orig
+  end
+
+  def test_config_for_lookup
+    Geocoder2.configure(
+      :timeout => 5,
+      :api_key => "aaa",
+      :google => {
+        :timeout => 2
+      }
+    )
+    assert_equal 2, Geocoder2.config_for_lookup(:google).timeout
+    assert_equal "aaa", Geocoder2.config_for_lookup(:google).api_key
+  end
+
+  def test_model_configuration
+    Landmark.reverse_geocoded_by :latitude, :longitude, :method => :spherical, :units => :km
+    assert_equal :km,        Landmark.geocoder2_options[:units]
+    assert_equal :spherical, Landmark.geocoder2_options[:method]
+
+    v = Landmark.new(*landmark_params(:msg))
+    v.latitude  = 0
+    v.longitude = 0
+    assert_equal 111, v.distance_to([0,1]).round
+    v.latitude  = 40.750354
+    v.longitude = -73.993371
+    assert_equal 136, v.bearing_from([50,-85]).round
+  end
+
+  def test_configuration_chain
+    v = Landmark.new(*landmark_params(:msg))
+    v.latitude  = 0
+    v.longitude = 0
+
+    # method option > global configuration
+    Geocoder2.configure(:units => :km)
+    assert_equal 69, v.distance_to([0,1], :mi).round
+
+    # per-model configuration > global configuration
+    Landmark.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/custom_block_test.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+require 'test_helper'
+
+class CustomBlockTest < Test::Unit::TestCase
+
+  def test_geocode_with_block_runs_block
+    e = Event.new(*venue_params(:msg))
+    coords = [40.750354, -73.993371]
+    e.geocode
+    assert_equal coords.map{ |c| c.to_s }.join(','), e.coords_string
+  end
+
+  def test_geocode_with_block_doesnt_auto_assign_coordinates
+    e = Event.new(*venue_params(:msg))
+    e.geocode
+    assert_nil e.latitude
+    assert_nil e.longitude
+  end
+
+  def test_reverse_geocode_with_block_runs_block
+    e = Party.new(*landmark_params(:msg))
+    e.reverse_geocode
+    assert_equal "US", e.country
+  end
+
+  def test_reverse_geocode_with_block_doesnt_auto_assign_address
+    e = Party.new(*landmark_params(:msg))
+    e.reverse_geocode
+    assert_nil e.address
+  end
+end
+

data/test/error_handling_test.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require 'test_helper'
+
+class ErrorHandlingTest < Test::Unit::TestCase
+
+  def teardown
+    Geocoder2.configure(:always_raise => [])
+  end
+
+  def test_does_not_choke_on_timeout
+    # keep test output clean: suppress timeout warning
+    orig = $VERBOSE; $VERBOSE = nil
+    Geocoder2::Lookup.all_services_except_test.each do |l|
+      Geocoder2.configure(:lookup => l)
+      set_api_key!(l)
+      assert_nothing_raised { Geocoder2.search("timeout") }
+    end
+  ensure
+    $VERBOSE = orig
+  end
+
+  def test_always_raise_timeout_error
+    Geocoder2.configure(:always_raise => [TimeoutError])
+    Geocoder2::Lookup.all_services_except_test.each do |l|
+      lookup = Geocoder2::Lookup.get(l)
+      set_api_key!(l)
+      assert_raises TimeoutError do
+        lookup.send(:results, Geocoder2::Query.new("timeout"))
+      end
+    end
+  end
+
+  def test_always_raise_socket_error
+    Geocoder2.configure(:always_raise => [SocketError])
+    Geocoder2::Lookup.all_services_except_test.each do |l|
+      lookup = Geocoder2::Lookup.get(l)
+      set_api_key!(l)
+      assert_raises SocketError do
+        lookup.send(:results, Geocoder2::Query.new("socket_error"))
+      end
+    end
+  end
+end

data/test/fixtures/baidu_invalid_key

@@ -0,0 +1 @@
+{"results":[],"status":5,"msg":"AK Illegal or Not Exist:"}

data/test/fixtures/baidu_no_results

@@ -0,0 +1 @@
+{"status":0,"result":[]}

data/test/fixtures/baidu_reverse

@@ -0,0 +1 @@
+{"status":0,"result":{"location":{"lng":121.48789948569,"lat":31.249161555654},"formatted_address":"上海市闸北区天潼路619号","business":"七浦路,海宁路,北京东路","addressComponent":{"city":"上海市","district":"闸北区","province":"上海市","street":"天潼路","street_number":"619号"},"cityCode":289}}

data/test/fixtures/baidu_shanghai_pearl_tower

@@ -0,0 +1,12 @@
+{
+	"status":0,
+		"result":{
+			"location":{
+				"lng":116.30814954222,
+				"lat":40.056885091681
+			},
+			"precise":1,
+			"confidence":80,
+			"level":"\u5546\u52a1\u5927\u53a6"
+		}
+}

data/test/fixtures/bing_invalid_key

@@ -0,0 +1 @@
+{"authenticationResultCode":"InvalidCredentials","brandLogoUri":"http:\\/\\/dev.virtualearth.net\\/Branding\\/logo_powered_by.png","copyright":"Copyright \xC2\xA9 2012 Microsoft and its suppliers. All rights reserved. This API cannot be accessed and the content and any results may not be used, reproduced or transmitted in any manner without express written permission from Microsoft Corporation.","errorDetails":["Access was denied. You may have entered your credentials incorrectly, or you might not have access to the requested resource or operation."],"resourceSets":[],"statusCode":401,"statusDescription":"Unauthorized","traceId":"5c539f6e70c44b2e858741b6c932318e|EWRM001670|02.00.83.1900|"}