fakeweb 1.2.4 → 1.2.5

data/CHANGELOG

@@ -1,3 +1,16 @@
+fakeweb (1.2.5)
+
+* fix handling of userinfo strings that contain percent-encoded unsafe
+  characters [Chris Kampmeier, Ken Mayer]
+
+* fix that exact matches against strings/URIs with the :any method had a lower
+  precedence than regex matches using a real HTTP method (exact matches now
+  always take precedence) [Chris Kampmeier]
+
+* change request handling to raise an exception when more than one registered
+  regex matches a request URI [Chris Kampmeier]
+
+
 fakeweb (1.2.4)
 
 * add experimental support for matching URIs via regular expressions

data/Rakefile

@@ -1,7 +1,15 @@
+puts "Using ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL}"
+
 require 'rubygems'
 require 'rake/gempackagetask'
 require 'rake/testtask'
-require 'rake/rdoctask'
+begin
+  require 'rdoc/task'
+rescue LoadError
+  puts "\nIt looks like you're using an old version of RDoc, but FakeWeb requires a newer one."
+  puts "You can try upgrading with `sudo gem install rdoc`.\n\n"
+  raise
+end
 
 task :default => :test
 
@@ -12,13 +20,12 @@ Rake::TestTask.new :test do |test|
 end
 
 desc "Generate Documentation"
-Rake::RDocTask.new do |rdoc|
+RDoc::Task.new do |rdoc|
   rdoc.main = "README.rdoc"
   rdoc.rdoc_dir = "doc"
   rdoc.rdoc_files.include("README.rdoc", "CHANGELOG", "LICENSE.txt", "lib/*.rb")
   rdoc.title = "FakeWeb API Documentation"
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.options << '--charset' << 'utf-8'
+  rdoc.options << '--line-numbers' << '--charset' << 'utf-8'
 end
 
 desc %{Update ".manifest" with the latest list of project filenames. Respect\
@@ -59,7 +66,6 @@ else
     t.test_files = FileList['test/**/test*.rb'] 
     t.rcov_opts << "--sort coverage"
     t.rcov_opts << "--exclude gems"
-    t.rcov_opts << "--no-validator-links"
   end
 end
 

data/lib/fake_web.rb

@@ -5,6 +5,7 @@ require 'fake_web/registry'
 require 'fake_web/response'
 require 'fake_web/responder'
 require 'fake_web/stub_socket'
+require 'fake_web/utility'
 
 module FakeWeb
 
@@ -45,6 +46,11 @@ module FakeWeb
   # stubbed.
   class NetConnectNotAllowedError < StandardError; end;
 
+  # This exception is raised if a Net::HTTP request matches more than one of
+  # the regular expression-based stubs you've registered. To fix the problem,
+  # disambiguate the regular expressions by making them more specific.
+  class MultipleMatchingRegexpsError < StandardError; end;
+
   # call-seq:
   #   FakeWeb.register_uri(method, uri, options)
   #

data/lib/fake_web/ext/net_http.rb

@@ -41,7 +41,8 @@ module Net  #:nodoc: all
       path = URI.parse(request.path).request_uri if request.path =~ /^http/
 
       if request["authorization"] =~ /^Basic /
-        userinfo = request["authorization"].sub(/^Basic /, "").unpack("m").first + "@"
+        userinfo = FakeWeb::Utility.decode_userinfo_from_header(request["authorization"])
+        userinfo = FakeWeb::Utility.encode_unsafe_chars_in_userinfo(userinfo) + "@"
       else
         userinfo = ""
       end
@@ -56,8 +57,7 @@ module Net  #:nodoc: all
         connect_without_fakeweb
         request_without_fakeweb(request, body, &block)
       else
-        uri.sub!(":80/", "/")  if uri =~ %r|^http://|
-        uri.sub!(":443/", "/") if uri =~ %r|^https://|
+        uri = FakeWeb::Utility.strip_default_port_from_uri(uri)
         raise FakeWeb::NetConnectNotAllowedError,
               "Real HTTP connections are disabled. Unregistered request: #{request.method} #{uri}"
       end

data/lib/fake_web/registry.rb

@@ -2,60 +2,30 @@ module FakeWeb
   class Registry #:nodoc:
     include Singleton
 
-    attr_accessor :uri_map, :pattern_map
+    attr_accessor :uri_map
 
     def initialize
       clean_registry
     end
 
     def clean_registry
-      self.uri_map = Hash.new do |hash, key|
-        hash[key] = Hash.new(&hash.default_proc)
-      end
-      self.pattern_map = []
+      self.uri_map = Hash.new { |hash, key| hash[key] = {} }
     end
 
     def register_uri(method, uri, options)
-      case uri
-      when URI, String
-        uri_map[normalize_uri(uri)][method] = [*[options]].flatten.collect do |option|
-          FakeWeb::Responder.new(method, uri, option, option[:times])
-        end
-      when Regexp
-        responders = [*[options]].flatten.collect do |option|
-          FakeWeb::Responder.new(method, uri, option, option[:times])
-        end
-        pattern_map << {:pattern => uri,
-                        :responders => responders,
-                        :method => method }
-
+      uri_map[normalize_uri(uri)][method] = [*[options]].flatten.collect do |option|
+        FakeWeb::Responder.new(method, uri, option, option[:times])
       end
     end
 
     def registered_uri?(method, uri)
       normalized_uri = normalize_uri(uri)
-      uri_map[normalized_uri].has_key?(method) || uri_map[normalized_uri].has_key?(:any) || pattern_map_matches?(method, uri) || pattern_map_matches?(:any, uri)
-    end
-
-    def registered_uri(method, uri)
-      uri = normalize_uri(uri)
-      registered = registered_uri?(method, uri)
-      if registered && uri_map[uri].has_key?(method)
-        uri_map[uri][method]
-      elsif registered && pattern_map_matches?(method, uri)
-        pattern_map_matches(method, uri).map{|m| m[:responders]}.flatten
-      elsif registered && uri_map[uri].has_key?(:any)
-        uri_map[uri][:any]
-      elsif registered && pattern_map_matches(:any, uri)
-        pattern_map_matches(:any, uri).map{|m| m[:responders]}.flatten
-      else
-        nil
-      end
+      !responses_for(method, uri).empty?
     end
 
     def response_for(method, uri, &block)
-      responses = registered_uri(method, uri)
-      return nil if responses.nil?
+      responses = responses_for(method, uri)
+      return nil if responses.empty?
 
       next_response = responses.last
       responses.each do |response|
@@ -69,24 +39,47 @@ module FakeWeb
       next_response.response(&block)
     end
 
-    def pattern_map_matches?(method, uri)
-      !pattern_map_matches(method, uri).empty?
-    end
 
-    def pattern_map_matches(method, uri)
-      uri = uri.to_s
-      uri.sub!(":80/", "/")  if uri =~ %r|^http://|
-      uri.sub!(":443/", "/") if uri =~ %r|^https://|
-      pattern_map.select { |p| uri.match(p[:pattern]) && p[:method] == method }
+    private
+
+    def responses_for(method, uri)
+      uri = normalize_uri(uri)
+
+      if uri_map[uri].has_key?(method)
+        uri_map[uri][method]
+      elsif uri_map[uri].has_key?(:any)
+        uri_map[uri][:any]
+      elsif uri_map_matches?(method, uri)
+        uri_map_matches(method, uri)
+      elsif uri_map_matches(:any, uri)
+        uri_map_matches(:any, uri)
+      else
+        []
+      end
     end
 
-    def pattern_map_match(method, uri)
-      pattern_map_matches(method, uri).first
+    def uri_map_matches?(method, uri)
+      !uri_map_matches(method, uri).nil?
     end
 
-    private
+    def uri_map_matches(method, uri)
+      uri = normalize_uri(uri.to_s).to_s
+      uri = Utility.strip_default_port_from_uri(uri)
+
+      matches = uri_map.select { |registered_uri, method_hash|
+        registered_uri.is_a?(Regexp) && uri.match(registered_uri) && method_hash.has_key?(method)
+      }
+
+      if matches.size > 1
+        raise MultipleMatchingRegexpsError,
+          "More than one regular expression matched this request: #{method.to_s.upcase} #{uri}"
+      end
+
+      matches.map { |_, method_hash| method_hash[method] }.first
+    end
 
     def normalize_uri(uri)
+      return uri if uri.is_a?(Regexp)
       normalized_uri =
         case uri
         when URI then uri

data/lib/fake_web/utility.rb

@@ -0,0 +1,22 @@
+module FakeWeb
+  module Utility #:nodoc:
+
+    def self.decode_userinfo_from_header(header)
+      header.sub(/^Basic /, "").unpack("m").first
+    end
+
+    def self.encode_unsafe_chars_in_userinfo(userinfo)
+      unsafe_in_userinfo = /[^#{URI::REGEXP::PATTERN::UNRESERVED};&=+$,]|^(#{URI::REGEXP::PATTERN::ESCAPED})/
+      userinfo.split(":").map { |part| URI.escape(part, unsafe_in_userinfo) }.join(":")
+    end
+
+    def self.strip_default_port_from_uri(uri)
+      case uri
+      when %r{^http://}  then uri.sub(%r{:80(/|$)}, '\1')
+      when %r{^https://} then uri.sub(%r{:443(/|$)}, '\1')
+      else uri
+      end
+    end
+
+  end
+end

data/test/test_allow_net_connect.rb

@@ -2,15 +2,6 @@ require File.join(File.dirname(__FILE__), "test_helper")
 
 class TestFakeWebAllowNetConnect < Test::Unit::TestCase
 
-  def setup
-    @original_allow_net_connect = FakeWeb.allow_net_connect?
-  end
-
-  def teardown
-    FakeWeb.allow_net_connect = @original_allow_net_connect
-  end
-
-
   def test_unregistered_requests_are_passed_through_when_allow_net_connect_is_true
     FakeWeb.allow_net_connect = true
     setup_expectations_for_real_apple_hot_news_request
@@ -79,8 +70,16 @@ class TestFakeWebAllowNetConnect < Test::Unit::TestCase
     assert !FakeWeb.allow_net_connect?
   end
 
+end
+
+
+class TestFakeWebAllowNetConnectWithCleanState < Test::Unit::TestCase
+  # Our test_helper.rb sets allow_net_connect = false in an inherited #setup
+  # method. Disable that here to test the default setting.
+  def setup; end
+  def teardown; end
+
   def test_allow_net_connect_is_true_by_default
     assert FakeWeb.allow_net_connect?
   end
-
 end

data/test/test_deprecations.rb

@@ -2,10 +2,6 @@ require File.join(File.dirname(__FILE__), "test_helper")
 
 class TestDeprecations < Test::Unit::TestCase
 
-  def setup
-    FakeWeb.clean_registry
-  end
-
   def test_register_uri_without_method_argument_prints_deprecation_warning
     warning = capture_stderr do
       FakeWeb.register_uri("http://example.com", :body => "test")

data/test/test_fake_authentication.rb

@@ -1,11 +1,6 @@
 require File.join(File.dirname(__FILE__), "test_helper")
 
 class TestFakeAuthentication < Test::Unit::TestCase
-  def setup
-    FakeWeb.register_uri(:get, 'http://user:pass@mock/auth.txt', :body => 'authorized')
-    FakeWeb.register_uri(:get, 'http://user2:pass@mock/auth.txt', :body => 'wrong user')
-    FakeWeb.register_uri(:get, 'http://mock/auth.txt', :body => 'unauthorized')
-  end
 
   def test_register_uri_with_authentication
     FakeWeb.register_uri(:get, 'http://user:pass@mock/test_example.txt', :body => "example")
@@ -23,23 +18,27 @@ class TestFakeAuthentication < Test::Unit::TestCase
   end
 
   def test_unauthenticated_request
+    FakeWeb.register_uri(:get, 'http://mock/auth.txt', :body => 'unauthorized')
     http = Net::HTTP.new('mock', 80)
     req = Net::HTTP::Get.new('/auth.txt')
     assert_equal 'unauthorized', http.request(req).body
   end
 
   def test_authenticated_request
+    FakeWeb.register_uri(:get, 'http://user:pass@mock/auth.txt', :body => 'authorized')
     http = Net::HTTP.new('mock',80)
     req = Net::HTTP::Get.new('/auth.txt')
     req.basic_auth 'user', 'pass'
     assert_equal 'authorized', http.request(req).body
   end
 
-  def test_incorrectly_authenticated_request
-    http = Net::HTTP.new('mock',80)
+  def test_authenticated_request_where_only_userinfo_differs
+    FakeWeb.register_uri(:get, 'http://user:pass@mock/auth.txt', :body => 'first user')
+    FakeWeb.register_uri(:get, 'http://user2:pass@mock/auth.txt', :body => 'second user')
+    http = Net::HTTP.new('mock')
     req = Net::HTTP::Get.new('/auth.txt')
     req.basic_auth 'user2', 'pass'
-    assert_equal 'wrong user', http.request(req).body
+    assert_equal 'second user', http.request(req).body
   end
 
   def test_basic_auth_support_is_transparent_to_oauth
@@ -65,4 +64,29 @@ class TestFakeAuthentication < Test::Unit::TestCase
     end
     assert_equal "secret", response.body
   end
+
+  def test_basic_auth_when_userinfo_contains_allowed_unencoded_characters
+    FakeWeb.register_uri(:get, "http://roses&hel1o,(+$):so;longs=@example.com", :body => "authorized")
+    http = Net::HTTP.new("example.com")
+    request = Net::HTTP::Get.new("/")
+    request.basic_auth("roses&hel1o,(+$)", "so;longs=")
+    assert_equal "authorized", http.request(request).body
+  end
+
+  def test_basic_auth_when_userinfo_contains_encoded_at_sign
+    FakeWeb.register_uri(:get, "http://user%40example.com:secret@example.com", :body => "authorized")
+    http = Net::HTTP.new("example.com")
+    request = Net::HTTP::Get.new("/")
+    request.basic_auth("user@example.com", "secret")
+    assert_equal "authorized", http.request(request).body
+  end
+
+  def test_basic_auth_when_userinfo_contains_allowed_encoded_characters
+    FakeWeb.register_uri(:get, "http://us%20er:sec%20%2F%2Fret%3F@example.com", :body => "authorized")
+    http = Net::HTTP.new("example.com")
+    request = Net::HTTP::Get.new("/")
+    request.basic_auth("us er", "sec //ret?")
+    assert_equal "authorized", http.request(request).body
+  end
+
 end

data/test/test_fake_web.rb

@@ -2,11 +2,6 @@ require File.join(File.dirname(__FILE__), "test_helper")
 
 class TestFakeWeb < Test::Unit::TestCase
 
-  def setup
-    FakeWeb.allow_net_connect = true
-    FakeWeb.clean_registry
-  end
-
   def test_register_uri
     FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => "example")
     assert FakeWeb.registered_uri?(:get, 'http://mock/test_example.txt')
@@ -131,26 +126,20 @@ class TestFakeWeb < Test::Unit::TestCase
 
   def test_content_for_registered_uri_with_port_and_request_with_port
     FakeWeb.register_uri(:get, 'http://example.com:3000/', :body => 'test example content')
-    Net::HTTP.start('example.com', 3000) do |http|
-      response = http.get('/')
-      assert_equal 'test example content', response.body
-    end
+    response = Net::HTTP.start('example.com', 3000) { |http| http.get('/') }
+    assert_equal 'test example content', response.body
   end
 
   def test_content_for_registered_uri_with_default_port_for_http_and_request_without_port
     FakeWeb.register_uri(:get, 'http://example.com:80/', :body => 'test example content')
-    Net::HTTP.start('example.com') do |http|
-      response = http.get('/')
-      assert_equal 'test example content', response.body
-    end
+    response = Net::HTTP.start('example.com') { |http| http.get('/') }
+    assert_equal 'test example content', response.body
   end
 
   def test_content_for_registered_uri_with_no_port_for_http_and_request_with_default_port
     FakeWeb.register_uri(:get, 'http://example.com/', :body => 'test example content')
-    Net::HTTP.start('example.com', 80) do |http|
-      response = http.get('/')
-      assert_equal 'test example content', response.body
-    end
+    response = Net::HTTP.start('example.com', 80) { |http| http.get('/') }
+    assert_equal 'test example content', response.body
   end
 
   def test_content_for_registered_uri_with_default_port_for_https_and_request_with_default_port
@@ -172,41 +161,35 @@ class TestFakeWeb < Test::Unit::TestCase
   def test_content_for_registered_uris_with_ports_on_same_domain_and_request_without_port
     FakeWeb.register_uri(:get, 'http://example.com:3000/', :body => 'port 3000')
     FakeWeb.register_uri(:get, 'http://example.com/', :body => 'port 80')
-    Net::HTTP.start('example.com') do |http|
-      response = http.get('/')
-      assert_equal 'port 80', response.body
-    end
+    response = Net::HTTP.start('example.com') { |http| http.get('/') }
+    assert_equal 'port 80', response.body
   end
 
   def test_content_for_registered_uris_with_ports_on_same_domain_and_request_with_port
     FakeWeb.register_uri(:get, 'http://example.com:3000/', :body => 'port 3000')
     FakeWeb.register_uri(:get, 'http://example.com/', :body => 'port 80')
-    Net::HTTP.start('example.com', 3000) do |http|
-      response = http.get('/')
-      assert_equal 'port 3000', response.body
-    end
+    response = Net::HTTP.start('example.com', 3000) { |http| http.get('/') }
+    assert_equal 'port 3000', response.body
   end
 
   def test_content_for_registered_uri_with_get_method_only
     FakeWeb.allow_net_connect = false
     FakeWeb.register_uri(:get, "http://example.com/", :body => "test example content")
-    Net::HTTP.start('example.com') do |http|
-      assert_equal 'test example content', http.get('/').body
-      assert_raises(FakeWeb::NetConnectNotAllowedError) { http.post('/', nil) }
-      assert_raises(FakeWeb::NetConnectNotAllowedError) { http.put('/', nil) }
-      assert_raises(FakeWeb::NetConnectNotAllowedError) { http.delete('/', nil) }
-    end
+    http = Net::HTTP.new('example.com')
+    assert_equal 'test example content', http.get('/').body
+    assert_raises(FakeWeb::NetConnectNotAllowedError) { http.post('/', nil) }
+    assert_raises(FakeWeb::NetConnectNotAllowedError) { http.put('/', nil) }
+    assert_raises(FakeWeb::NetConnectNotAllowedError) { http.delete('/') }
   end
 
   def test_content_for_registered_uri_with_any_method_explicitly
     FakeWeb.allow_net_connect = false
     FakeWeb.register_uri(:any, "http://example.com/", :body => "test example content")
-    Net::HTTP.start('example.com') do |http|
-      assert_equal 'test example content', http.get('/').body
-      assert_equal 'test example content', http.post('/', nil).body
-      assert_equal 'test example content', http.put('/', nil).body
-      assert_equal 'test example content', http.delete('/').body
-    end
+    http = Net::HTTP.new('example.com')
+    assert_equal 'test example content', http.get('/').body
+    assert_equal 'test example content', http.post('/', nil).body
+    assert_equal 'test example content', http.put('/', nil).body
+    assert_equal 'test example content', http.delete('/').body
   end
 
   def test_content_for_registered_uri_with_any_method_implicitly
@@ -215,83 +198,84 @@ class TestFakeWeb < Test::Unit::TestCase
       FakeWeb.register_uri("http://example.com/", :body => "test example content")
     end
 
-    Net::HTTP.start('example.com') do |http|
-      assert_equal 'test example content', http.get('/').body
-      assert_equal 'test example content', http.post('/', nil).body
-      assert_equal 'test example content', http.put('/', nil).body
-      assert_equal 'test example content', http.delete('/').body
-    end
+    http = Net::HTTP.new('example.com')
+    assert_equal 'test example content', http.get('/').body
+    assert_equal 'test example content', http.post('/', nil).body
+    assert_equal 'test example content', http.put('/', nil).body
+    assert_equal 'test example content', http.delete('/').body
   end
 
   def test_mock_request_with_block
     FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => File.dirname(__FILE__) + '/fixtures/test_example.txt')
-    Net::HTTP.start('mock') do |http|
-      response = http.get('/test_example.txt')
-      assert_equal 'test example content', response.body
+    response = Net::HTTP.start('mock') { |http| http.get('/test_example.txt') }
+    assert_equal 'test example content', response.body
+  end
+
+  def test_request_with_registered_body_yields_the_response_body_to_a_request_block
+    FakeWeb.register_uri(:get, "http://example.com", :body => "content")
+    body = nil
+    Net::HTTP.start("example.com") do |http|
+      http.get("/") do |response_body|
+        body = response_body
+      end
+    end
+    assert_equal "content", body
+  end
+
+  def test_request_with_registered_response_yields_the_response_body_to_a_request_block
+    fake_response = Net::HTTPOK.new('1.1', '200', 'OK')
+    fake_response.instance_variable_set(:@body, "content")
+    FakeWeb.register_uri(:get, 'http://example.com', :response => fake_response)
+    body = nil
+    Net::HTTP.start("example.com") do |http|
+      http.get("/") do |response_body|
+        body = response_body
+      end
     end
+    assert_equal "content", body
   end
 
   def test_mock_request_with_undocumented_full_uri_argument_style
     FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => File.dirname(__FILE__) + '/fixtures/test_example.txt')
-    Net::HTTP.start('mock') do |query|
-      response = query.get('http://mock/test_example.txt')
-      assert_equal 'test example content', response.body
-    end
+    response = Net::HTTP.start('mock') { |query| query.get('http://mock/test_example.txt') }
+    assert_equal 'test example content', response.body
   end
 
   def test_mock_request_with_undocumented_full_uri_argument_style_and_query
     FakeWeb.register_uri(:get, 'http://mock/test_example.txt?a=b', :body => 'test query content')
-    Net::HTTP.start('mock') do |query|
-      response = query.get('http://mock/test_example.txt?a=b')
-      assert_equal 'test query content', response.body
-    end
+    response = Net::HTTP.start('mock') { |query| query.get('http://mock/test_example.txt?a=b') }
+    assert_equal 'test query content', response.body
   end
 
   def test_mock_post
     FakeWeb.register_uri(:post, 'http://mock/test_example.txt', :body => File.dirname(__FILE__) + '/fixtures/test_example.txt')
-    response = nil
-    Net::HTTP.start('mock') do |query|
-      response = query.post('/test_example.txt', '')
-    end
+    response = Net::HTTP.start('mock') { |query| query.post('/test_example.txt', '') }
     assert_equal 'test example content', response.body
   end
 
   def test_mock_post_with_string_as_registered_uri
-    response = nil
     FakeWeb.register_uri(:post, 'http://mock/test_string.txt', :body => 'foo')
-    Net::HTTP.start('mock') do |query|
-      response = query.post('/test_string.txt', '')
-    end
+    response = Net::HTTP.start('mock') { |query| query.post('/test_string.txt', '') }
     assert_equal 'foo', response.body
   end
 
   def test_mock_get_with_request_as_registered_uri
     fake_response = Net::HTTPOK.new('1.1', '200', 'OK')
     FakeWeb.register_uri(:get, 'http://mock/test_response', :response => fake_response)
-    response = nil
-    Net::HTTP.start('mock') do |query|
-      response = query.get('/test_response')
-    end
-
+    response = Net::HTTP.start('mock') { |query| query.get('/test_response') }
     assert_equal fake_response, response
   end
 
   def test_mock_get_with_request_from_file_as_registered_uri
     FakeWeb.register_uri(:get, 'http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_without_transfer_encoding')
-    response = nil
-    Net::HTTP.start('www.google.com') do |query|
-      response = query.get('/')
-    end
+    response = Net::HTTP.start('www.google.com') { |query| query.get('/') }
     assert_equal '200', response.code
     assert response.body.include?('<title>Google</title>')
   end
 
   def test_mock_post_with_request_from_file_as_registered_uri
     FakeWeb.register_uri(:post, 'http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_without_transfer_encoding')
-    response = nil
-    Net::HTTP.start('www.google.com') do |query|
-      response = query.post('/', '')
-    end
+    response = Net::HTTP.start('www.google.com') { |query| query.post('/', '') }
     assert_equal "200", response.code
     assert response.body.include?('<title>Google</title>')
   end
@@ -299,13 +283,12 @@ class TestFakeWeb < Test::Unit::TestCase
   def test_proxy_request
     FakeWeb.register_uri(:get, 'http://www.example.com/', :body => "hello world")
     FakeWeb.register_uri(:get, 'http://your.proxy.host/', :body => "lala")
-    proxy_addr = 'your.proxy.host'
-    proxy_port = 8080
 
-    Net::HTTP::Proxy(proxy_addr, proxy_port).start('www.example.com') do |http|
+    response = nil
+    Net::HTTP::Proxy('your.proxy.host', 8080).start('www.example.com') do |http|
       response = http.get('/')
-      assert_equal "hello world", response.body
     end
+    assert_equal "hello world", response.body
   end
 
   def test_https_request
@@ -324,6 +307,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_real_http_request
+    FakeWeb.allow_net_connect = true
     setup_expectations_for_real_apple_hot_news_request
 
     resp = nil
@@ -335,6 +319,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_real_http_request_with_undocumented_full_uri_argument_style
+    FakeWeb.allow_net_connect = true
     setup_expectations_for_real_apple_hot_news_request(:path => 'http://images.apple.com/main/rss/hotnews/hotnews.rss')
 
     resp = nil
@@ -346,6 +331,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_real_https_request
+    FakeWeb.allow_net_connect = true
     setup_expectations_for_real_apple_hot_news_request(:port => 443)
 
     http = Net::HTTP.new('images.apple.com', 443)
@@ -357,6 +343,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_real_request_on_same_domain_as_mock
+    FakeWeb.allow_net_connect = true
     setup_expectations_for_real_apple_hot_news_request
 
     FakeWeb.register_uri(:get, 'http://images.apple.com/test_string.txt', :body => 'foo')
@@ -432,16 +419,14 @@ class TestFakeWeb < Test::Unit::TestCase
 
   def test_response_type
     FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => "test")
-    Net::HTTP.start('mock') do |http|
-      response = http.get('/test_example.txt')
-      assert_kind_of(Net::HTTPSuccess, response)
-    end
+    response = Net::HTTP.start('mock') { |http| http.get('/test_example.txt') }
+    assert_kind_of Net::HTTPSuccess, response
   end
 
   def test_mock_request_that_raises_an_http_error_with_a_specific_status
     FakeWeb.register_uri(:get, 'http://mock/raising_exception.txt', :exception => Net::HTTPError, :status => ['404', 'Not Found'])
     exception = assert_raises(Net::HTTPError) do
-      Net::HTTP.start('mock') { |http| response = http.get('/raising_exception.txt') }
+      Net::HTTP.start('mock') { |http| http.get('/raising_exception.txt') }
     end
     assert_equal '404', exception.response.code
     assert_equal 'Not Found', exception.response.msg
@@ -461,10 +446,7 @@ class TestFakeWeb < Test::Unit::TestCase
 
   def test_mock_request_using_response_with_transfer_encoding_header_has_valid_transfer_encoding_header
     FakeWeb.register_uri(:get, 'http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_with_transfer_encoding')
-    response = nil
-    Net::HTTP.start('www.google.com') do |query|
-      response = query.get('/')
-    end
+    response = Net::HTTP.start('www.google.com') { |query| query.get('/') }
     assert_not_nil response['transfer-encoding']
     assert response['transfer-encoding'] == 'chunked'
   end
@@ -472,28 +454,20 @@ class TestFakeWeb < Test::Unit::TestCase
   def test_mock_request_using_response_without_transfer_encoding_header_does_not_have_a_transfer_encoding_header
     FakeWeb.register_uri(:get, 'http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_without_transfer_encoding')
     response = nil
-    Net::HTTP.start('www.google.com') do |query|
-      response = query.get('/')
-    end
+    response = Net::HTTP.start('www.google.com') { |query| query.get('/') }
     assert !response.key?('transfer-encoding')
   end
 
   def test_mock_request_using_response_from_curl_has_original_transfer_encoding_header
     FakeWeb.register_uri(:get, 'http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_from_curl')
-    response = nil
-    Net::HTTP.start('www.google.com') do |query|
-      response = query.get('/')
-    end
+    response = Net::HTTP.start('www.google.com') { |query| query.get('/') }
     assert_not_nil response['transfer-encoding']
     assert response['transfer-encoding'] == 'chunked'
   end
 
   def test_txt_file_should_have_three_lines
     FakeWeb.register_uri(:get, 'http://www.google.com/', :body => File.dirname(__FILE__) + '/fixtures/test_txt_file')
-    response = nil
-    Net::HTTP.start('www.google.com') do |query|
-      response = query.get('/')
-    end
+    response = Net::HTTP.start('www.google.com') { |query| query.get('/') }
     assert response.body.split(/\n/).size == 3, "response has #{response.body.split(/\n/).size} lines should have 3"
   end
 

data/test/test_fake_web_open_uri.rb

@@ -2,10 +2,6 @@ require File.join(File.dirname(__FILE__), "test_helper")
 
 class TestFakeWebOpenURI < Test::Unit::TestCase
 
-  def setup
-    FakeWeb.clean_registry
-  end
-
   def test_content_for_registered_uri
     FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => File.dirname(__FILE__) + '/fixtures/test_example.txt')
     assert_equal 'test example content', FakeWeb.response_for(:get, 'http://mock/test_example.txt').body
@@ -22,6 +18,7 @@ class TestFakeWebOpenURI < Test::Unit::TestCase
   end
   
   def test_real_open
+    FakeWeb.allow_net_connect = true
     setup_expectations_for_real_apple_hot_news_request
     resp = open('http://images.apple.com/main/rss/hotnews/hotnews.rss')
     assert_equal "200", resp.status.first
@@ -55,8 +52,7 @@ class TestFakeWebOpenURI < Test::Unit::TestCase
 
   def test_mock_open_with_block
     FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => File.dirname(__FILE__) + '/fixtures/test_example.txt')
-    open('http://mock/test_example.txt') do |f|
-      assert 'test example content', f.readlines
-    end
+    body = open('http://mock/test_example.txt') { |f| f.readlines }
+    assert_equal 'test example content', body.first
   end
 end

data/test/test_helper.rb

@@ -6,6 +6,21 @@ require 'fake_web'
 require 'rubygems'
 require 'mocha'
 
+
+# Give all tests a common setup and teardown that prevents shared state
+class Test::Unit::TestCase
+  def setup
+    FakeWeb.clean_registry
+    @original_allow_net_connect = FakeWeb.allow_net_connect?
+    FakeWeb.allow_net_connect = false
+  end
+
+  def teardown
+    FakeWeb.allow_net_connect = @original_allow_net_connect
+  end
+end
+
+
 module FakeWebTestHelper
 
   def capture_stderr
@@ -40,7 +55,6 @@ module FakeWebTestHelper
     request_parts = ["#{options[:method]} #{options[:path]} HTTP/1.1", "Host: #{options[:host]}"]
     socket.expects(:write).with(all_of(includes(request_parts[0]), includes(request_parts[1]))).returns(100)
 
-    # TODO: handle long response bodies that use more than one #sysread call
     socket.expects(:sysread).at_least_once.returns("HTTP/1.1 #{options[:response_code]} #{options[:response_message]}\nContent-Length: #{options[:response_body].length}\n\n#{options[:response_body]}").then.raises(EOFError)
   end
 

data/test/test_missing_open_uri.rb

@@ -3,12 +3,13 @@ require File.join(File.dirname(__FILE__), "test_helper")
 class TestMissingOpenURI < Test::Unit::TestCase
 
   def setup
-    FakeWeb.clean_registry
+    super
     @saved_open_uri = OpenURI
     Object.send(:remove_const, :OpenURI)
   end
 
   def teardown
+    super
     Object.const_set(:OpenURI, @saved_open_uri)
   end
 

data/test/test_precedence.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestPrecedence < Test::Unit::TestCase
+
+  def test_matching_get_strings_have_precedence_over_matching_get_regexes
+    FakeWeb.register_uri(:get, "http://example.com/test", :body => "string")
+    FakeWeb.register_uri(:get, %r|http://example\.com/test|, :body => "regex")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "string", response.body
+  end
+
+  def test_matching_any_strings_have_precedence_over_matching_any_regexes
+    FakeWeb.register_uri(:any, "http://example.com/test", :body => "string")
+    FakeWeb.register_uri(:any, %r|http://example\.com/test|, :body => "regex")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "string", response.body
+  end
+
+  def test_matching_get_strings_have_precedence_over_matching_any_strings
+    FakeWeb.register_uri(:get, "http://example.com/test", :body => "get method")
+    FakeWeb.register_uri(:any, "http://example.com/test", :body => "any method")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "get method", response.body
+
+    # registration order should not matter
+    FakeWeb.register_uri(:any, "http://example.com/test2", :body => "any method")
+    FakeWeb.register_uri(:get, "http://example.com/test2", :body => "get method")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test2') }
+    assert_equal "get method", response.body
+  end
+
+  def test_matching_any_strings_have_precedence_over_matching_get_regexes
+    FakeWeb.register_uri(:any, "http://example.com/test", :body => "any string")
+    FakeWeb.register_uri(:get, %r|http://example\.com/test|, :body => "get regex")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "any string", response.body
+  end
+
+  def test_registered_strings_and_uris_are_equivalent_so_second_takes_precedence
+    FakeWeb.register_uri(:get, "http://example.com/test", :body => "string")
+    FakeWeb.register_uri(:get, URI.parse("http://example.com/test"), :body => "uri")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "uri", response.body
+
+    FakeWeb.register_uri(:get, URI.parse("http://example.com/test2"), :body => "uri")
+    FakeWeb.register_uri(:get, "http://example.com/test2", :body => "string")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test2') }
+    assert_equal "string", response.body
+  end
+
+end

data/test/test_query_string.rb

@@ -2,10 +2,6 @@ require File.join(File.dirname(__FILE__), "test_helper")
 
 class TestFakeWebQueryString < Test::Unit::TestCase
 
-  def setup
-    FakeWeb.clean_registry
-  end
-
   def test_register_uri_string_with_query_params
     FakeWeb.register_uri(:get, 'http://example.com/?a=1&b=1', :body => 'foo')
     assert FakeWeb.registered_uri?(:get, 'http://example.com/?a=1&b=1')

data/test/test_regexes.rb

@@ -2,15 +2,6 @@ require File.join(File.dirname(__FILE__), "test_helper")
 
 class TestRegexes < Test::Unit::TestCase
 
-  def setup
-    FakeWeb.clean_registry
-    @original_allow_net_connect = FakeWeb.allow_net_connect?
-  end
-
-  def teardown
-    FakeWeb.allow_net_connect = @old_allow_net_conncet
-  end
-
   def test_registered_uri_with_pattern
     FakeWeb.register_uri(:get, %r|http://example.com/test_example/\d+|, :body => "example")
     assert FakeWeb.registered_uri?(:get, "http://example.com/test_example/25")
@@ -22,6 +13,11 @@ class TestRegexes < Test::Unit::TestCase
     assert_equal "Welcome to Google!", FakeWeb.response_for(:get, "http://www.google.com").body
   end
 
+  def test_response_for_with_matching_registered_uri_and_get_method_matching_to_any_method
+    FakeWeb.register_uri(:any, %r|http://www.example.com|, :body => "example")
+    assert_equal "example", FakeWeb.response_for(:get, "http://www.example.com").body
+  end
+
   def test_registered_uri_with_authentication_and_pattern
     FakeWeb.register_uri(:get, %r|http://user:pass@mock/example\.\w+|i, :body => "example")
     assert FakeWeb.registered_uri?(:get, 'http://user:pass@mock/example.txt')
@@ -40,11 +36,22 @@ class TestRegexes < Test::Unit::TestCase
     assert_equal "example", http.request(req).body
   end
 
-  def test_registering_with_overlapping_regexes_uses_first_registered
+  def test_requesting_a_uri_that_matches_two_registered_regexes_raises_an_error
+    FakeWeb.register_uri(:get, %r|http://example\.com/|, :body => "first")
+    FakeWeb.register_uri(:get, %r|http://example\.com/a|, :body => "second")
+    assert_raise FakeWeb::MultipleMatchingRegexpsError do
+      Net::HTTP.start("example.com") { |query| query.get('/a') }
+    end
+  end
+
+  def test_requesting_a_uri_that_matches_two_registered_regexes_raises_an_error_including_request_info
     FakeWeb.register_uri(:get, %r|http://example\.com/|, :body => "first")
     FakeWeb.register_uri(:get, %r|http://example\.com/a|, :body => "second")
-    response = Net::HTTP.start("example.com") { |query| query.get('/a') }
-    assert_equal "first", response.body
+    begin
+      Net::HTTP.start("example.com") { |query| query.get('/a') }
+    rescue FakeWeb::MultipleMatchingRegexpsError => exception
+    end
+    assert exception.message.include?("GET http://example.com/a")
   end
 
   def test_registry_does_not_find_using_mismatched_protocols_or_ports_when_registered_with_both

data/test/test_response_headers.rb

@@ -2,10 +2,6 @@ require File.join(File.dirname(__FILE__), "test_helper")
 
 class TestResponseHeaders < Test::Unit::TestCase
 
-  def setup
-    FakeWeb.clean_registry
-  end
-
   def test_content_type_when_registering_with_string_and_content_type_header
     FakeWeb.register_uri(:get, "http://example.com/users.json", :body => '[{"username": "chrisk"}]', :content_type => "application/json")
     response = Net::HTTP.start("example.com") { |query| query.get("/users.json") }
@@ -45,17 +41,17 @@ class TestResponseHeaders < Test::Unit::TestCase
                                                    :content_type => "text/plain"},
                                 {:body => 'test2', :expires => "Thu, 14 Jun 2009 16:00:01 GMT"}])
 
+    first_response = second_response = nil
     Net::HTTP.start("example.com") do |query|
-      response = query.get("/")
-      assert_equal 'test1', response.body
-      assert_equal "Thu, 14 Jun 2009 16:00:00 GMT", response['Expires']
-      assert_equal "text/plain", response['Content-Type']
-
-      response = query.get("/")
-      assert_equal 'test2', response.body
-      assert_equal "Thu, 14 Jun 2009 16:00:01 GMT", response['Expires']
-      assert_nil response['Content-Type']
+      first_response = query.get("/")
+      second_response = query.get("/")
     end
+    assert_equal 'test1', first_response.body
+    assert_equal "Thu, 14 Jun 2009 16:00:00 GMT", first_response['Expires']
+    assert_equal "text/plain", first_response['Content-Type']
+    assert_equal 'test2', second_response.body
+    assert_equal "Thu, 14 Jun 2009 16:00:01 GMT", second_response['Expires']
+    assert_nil second_response['Content-Type']
   end
 
   def test_registering_with_status_option_and_response_headers

data/test/test_trailing_slashes.rb

@@ -2,15 +2,6 @@ require File.join(File.dirname(__FILE__), "test_helper")
 
 class TestFakeWebTrailingSlashes < Test::Unit::TestCase
 
-  def setup
-    FakeWeb.clean_registry
-    @original_allow_net_connect = FakeWeb.allow_net_connect?
-  end
-
-  def teardown
-    FakeWeb.allow_net_connect = @old_allow_net_conncet
-  end
-
   def test_registering_root_without_slash_and_ask_predicate_method_with_slash
     FakeWeb.register_uri(:get, "http://www.example.com", :body => "root")
     assert FakeWeb.registered_uri?(:get, "http://www.example.com/")

data/test/test_utility.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestUtility < Test::Unit::TestCase
+
+  def test_decode_userinfo_from_header_handles_basic_auth
+    authorization_header = "Basic dXNlcm5hbWU6c2VjcmV0"
+    userinfo = FakeWeb::Utility.decode_userinfo_from_header(authorization_header)
+    assert_equal "username:secret", userinfo
+  end
+
+  def test_encode_unsafe_chars_in_userinfo_does_not_encode_userinfo_safe_punctuation
+    userinfo = "user;&=+$,:secret"
+    assert_equal userinfo, FakeWeb::Utility.encode_unsafe_chars_in_userinfo(userinfo)
+  end
+
+  def test_encode_unsafe_chars_in_userinfo_does_not_encode_rfc_3986_unreserved_characters
+    userinfo = "-_.!~*'()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:secret"
+    assert_equal userinfo, FakeWeb::Utility.encode_unsafe_chars_in_userinfo(userinfo)
+  end
+
+  def test_encode_unsafe_chars_in_userinfo_does_encode_other_characters
+    userinfo, safe_userinfo = 'us#rn@me:sec//ret?"', 'us%23rn%40me:sec%2F%2Fret%3F%22'
+    assert_equal safe_userinfo, FakeWeb::Utility.encode_unsafe_chars_in_userinfo(userinfo)
+  end
+
+  def test_strip_default_port_from_uri_strips_80_from_http_with_path
+    uri = "http://example.com:80/foo/bar"
+    stripped_uri = FakeWeb::Utility.strip_default_port_from_uri(uri)
+    assert_equal "http://example.com/foo/bar", stripped_uri
+  end
+
+  def test_strip_default_port_from_uri_strips_80_from_http_without_path
+    uri = "http://example.com:80"
+    stripped_uri = FakeWeb::Utility.strip_default_port_from_uri(uri)
+    assert_equal "http://example.com", stripped_uri
+  end
+
+  def test_strip_default_port_from_uri_strips_443_from_https_without_path
+    uri = "https://example.com:443"
+    stripped_uri = FakeWeb::Utility.strip_default_port_from_uri(uri)
+    assert_equal "https://example.com", stripped_uri
+  end
+
+  def test_strip_default_port_from_uri_strips_443_from_https
+    uri = "https://example.com:443/foo/bar"
+    stripped_uri = FakeWeb::Utility.strip_default_port_from_uri(uri)
+    assert_equal "https://example.com/foo/bar", stripped_uri
+  end
+
+  def test_strip_default_port_from_uri_does_not_strip_8080_from_http
+    uri = "http://example.com:8080/foo/bar"
+    assert_equal uri, FakeWeb::Utility.strip_default_port_from_uri(uri)
+  end
+
+  def test_strip_default_port_from_uri_does_not_strip_443_from_http
+    uri = "http://example.com:443/foo/bar"
+    assert_equal uri, FakeWeb::Utility.strip_default_port_from_uri(uri)
+  end
+
+  def test_strip_default_port_from_uri_does_not_strip_80_from_query_string
+    uri = "http://example.com/?a=:80&b=c"
+    assert_equal uri, FakeWeb::Utility.strip_default_port_from_uri(uri)
+  end
+
+  def test_strip_default_port_from_uri_does_not_modify_strings_that_do_not_start_with_http_or_https
+    uri = "httpz://example.com:80/"
+    assert_equal uri, FakeWeb::Utility.strip_default_port_from_uri(uri)
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fakeweb
 version: !ruby/object:Gem::Version 
-  version: 1.2.4
+  version: 1.2.5
 platform: ruby
 authors: 
 - Chris Kampmeier
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-24 00:00:00 -07:00
+date: 2009-07-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,18 +40,14 @@ files:
 - LICENSE.txt
 - README.rdoc
 - Rakefile
-- lib
-- lib/fake_web
 - lib/fake_web.rb
-- lib/fake_web/ext
 - lib/fake_web/ext/net_http.rb
 - lib/fake_web/registry.rb
 - lib/fake_web/responder.rb
 - lib/fake_web/response.rb
 - lib/fake_web/stub_socket.rb
+- lib/fake_web/utility.rb
 - lib/fakeweb.rb
-- test
-- test/fixtures
 - test/fixtures/google_response_from_curl
 - test/fixtures/google_response_with_transfer_encoding
 - test/fixtures/google_response_without_transfer_encoding
@@ -64,12 +60,16 @@ files:
 - test/test_fake_web_open_uri.rb
 - test/test_helper.rb
 - test/test_missing_open_uri.rb
+- test/test_precedence.rb
 - test/test_query_string.rb
 - test/test_regexes.rb
 - test/test_response_headers.rb
 - test/test_trailing_slashes.rb
+- test/test_utility.rb
 has_rdoc: true
 homepage: http://github.com/chrisk/fakeweb
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -97,12 +97,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: fakeweb
-rubygems_version: 1.3.0
+rubygems_version: 1.3.4
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: A tool for faking responses to HTTP requests
 test_files: 
-- test/fixtures
 - test/fixtures/google_response_from_curl
 - test/fixtures/google_response_with_transfer_encoding
 - test/fixtures/google_response_without_transfer_encoding
@@ -115,7 +114,9 @@ test_files:
 - test/test_fake_web_open_uri.rb
 - test/test_helper.rb
 - test/test_missing_open_uri.rb
+- test/test_precedence.rb
 - test/test_query_string.rb
 - test/test_regexes.rb
 - test/test_response_headers.rb
 - test/test_trailing_slashes.rb
+- test/test_utility.rb