fakeweb 1.1.2 → 1.2.0

data/CHANGELOG

@@ -1,30 +1,92 @@
+fakeweb (1.2.0)
+
+* add lib/fakeweb.rb so you can require "fakeweb" as well [Chris Kampmeier]
+
+* fix compatibility with Ruby 1.9.1 [Chris Kampmeier]
+
+* fix that newlines in file-based responses could be doubled in the response
+  object's body [Mark Menard, Chris Kampmeier]
+
+* fix unnecessary munging of the transfer-encoding header, which improves
+  compatibility with mechanize [Mark Menard]
+
+* fix a test and the RCov dependency to be compatible with JRuby [Mark Menard]
+
+* remove an unnecessary redefinition of OpenURI::HTTPError [Josh Nichols]
+
+* rearrange implementation code into separate files, one per class [Josh Nichols]
+
+* fix a bug where FakeWeb.response_for would raise if the request wasn't
+  registered [Chris Kampmeier]
+
+* add HTTP method support, so FakeWeb takes both the URI and method into
+  account for registration, requests, and responses. Backwards-compatible with
+  the old method signatures, which didn't have a method param. [Chris Kampmeier]
+
+* start work on Ruby 1.9 compatibility [Chris Kampmeier]
+
+* add FakeWeb.allow_net_connect= to enable/disable the pass-through to
+  Net::HTTP for unregistered URIs [Mislav Marohnić, Chris Kampmeier]
+
+* remove setup.rb, since most people use RubyGems [Mislav Marohnić]
+
+* fix that 'http://example.com/?' (empty query) matches a registered
+  'http://example.com/', and vice-versa [Mislav Marohnić]
+
+* improve the test suite to not rely on an internet connection [Chris Kampmeier]
+
+* use `rake test` instead of `rake tests` [Josh Nichols]
+
+* fix an incompatibility with Ruby 1.8.6 p36 where you'd get "Errno::EINTR:
+  Interrupted system call" exceptions in Socket#sysread for any non-faked
+  request [Chris Kampmeier]
+
+* response rotation: you can now optionally call FakeWeb.register_uri with an
+  array of options hashes; these are used, in order, to respond to
+  repeated requests (to repeat a response more than once before rotating, use
+  the :times option). Once you run out of responses, further requests always
+  receive the last response. [Michael Shapiro]
+
+* add support for Net::HTTP's undocumented full-URI request style (fixes
+  URI::InvalidURIErrors that you might see in older libraries) [Chris Kampmeier]
+
+* sort query params before storing internally, so that
+  http://example.com/?a=1&b=2 and http://example.com/?b=2&a=1 are considered the
+  same URL (although this is technically incorrect, it's much more
+  convenient--most web apps work that way, and Net::HTTP's use of a hash to pass
+  query params means that the order in which FakeWeb stores them can be
+  unpredictable) [Chris Kampmeier]
+
+* add support for ports in URLs, so that http://example.com/ and
+  http://example.com:3000/ are not the same [Chris Kampmeier]
+
+* fix for non-faked SSL requests failing with "Unable to create local socket"
+  [Chris Kampmeier]
+
+* update Rakefile to fix warning about deprecated code [Chris Kampmeier]
+
+
 fakeweb (1.1.2)
 
-  [ Blaine Cook ]
-  * add required dependencies to GemSpec to ensure that tests pass in
-    firebrigade (http://firebrigade.seattlerb.org/)
+* add required dependencies to GemSpec to ensure that tests pass in firebrigade
+  (http://firebrigade.seattlerb.org/) [Blaine Cook]
 
--- Blaine Cook <romeda@gmail.com>  Wed,  31 Aug 2007 17:26:04 -0800
 
 fakeweb (1.1.1)
 
-  [ Blaine Cook ]
-  * fix for non-existance of :string method on File as presented by open-uri
-  * fix for curl example test - google redirects to ccTLDs for those outside US
+* fix for non-existence of :string method on File as presented by open-uri
+  [Blaine Cook]
+
+* fix for curl example test - google redirects to ccTLDs for those outside US
+  [Blaine Cook]
 
--- Blaine Cook <romeda@gmail.com>  Thu,  03 Aug 2006 03:41:48 -0800
 
 fakeweb (1.1.0)
 
-  [ Blaine Cook ]
-  * update code to correspond to ruby 1.8.4
-  * breaks compatibility with ruby 1.8.2
+* update code to correspond to ruby 1.8.4 (breaks compatibility with ruby 1.8.2)
+  [Blaine Cook]
 
--- Blaine Cook <romeda@gmail.com>  Tue,  23 May 2006 16:13:26 -0800
 
 fakeweb (1.0.0)
 
-  [ Blaine Cook ]
-  * initial import
-
--- Blaine Cook <romeda@gmail.com>  Mon,  22 May 2006 11:53:42 -0800
+  * initial import [Blaine Cook]

data/README.rdoc

@@ -0,0 +1,162 @@
+= FakeWeb
+
+FakeWeb is a helper for faking web requests in Ruby. It works at a global
+level, without modifying code or writing extensive stubs.
+
+
+== Installation
+
+The latest release of FakeWeb is once again available from your friendly
+RubyForge mirror. Just install the gem:
+
+  sudo gem install fakeweb
+
+
+== Help and discussion
+
+RDocs for the current release are available at http://fakeweb.rubyforge.org.
+
+There's a mailing list for questions and discussion at
+http://groups.google.com/group/fakeweb-users.
+
+
+== Examples
+
+Start by requiring FakeWeb:
+
+  require 'rubygems'
+  require 'fakeweb'
+
+=== Registering basic string responses
+
+  FakeWeb.register_uri(:get, "http://example.com/test1", :string => "Hello World!")
+
+  Net::HTTP.get(URI.parse("http://example.com/test1"))
+  => "Hello World!"
+
+  Net::HTTP.get(URI.parse("http://example.com/test2"))
+  => FakeWeb is bypassed and the response from a real request is returned
+
+=== Replaying a recorded response
+
+  page = `curl -is http://www.google.com/`
+  FakeWeb.register_uri(:get, "http://www.google.com/", :response => page)
+
+  Net::HTTP.get(URI.parse("http://www.google.com/"))
+  # => Full response, including headers
+
+=== Adding a custom status to the response
+
+  FakeWeb.register_uri(:get, "http://example.com/", :string => "Nothing to be found 'round here",
+                                                    :status => ["404", "Not Found"])
+
+  Net::HTTP.start("example.com") do |req|
+    response = req.get("/")
+    response.code     # => "404"
+    response.message  # => "Not Found"
+    response.body     # => "Nothing to be found 'round here"
+  end
+
+=== Responding to any HTTP method
+
+  FakeWeb.register_uri(:any, "http://example.com", :string => "response for any HTTP method")
+
+If you use the <tt>:any</tt> symbol, the URI you specify will be completely
+stubbed out (regardless of the HTTP method of the request). This can be useful
+for RPC-like services, where the HTTP method isn't significant. (Older
+versions of FakeWeb always behaved like this, and didn't accept the first
++method+ argument above; this syntax is still supported, for
+backwards-compatibility, but it will probably be deprecated at some point.)
+
+=== Rotating responses
+
+You can optionally call FakeWeb.register_uri with an array of options hashes;
+these are used, in order, to respond to repeated requests. Once you run out of
+responses, further requests always receive the last response. (You can also send
+a response more than once before rotating, by specifying a <tt>:times</tt>
+option for that response.)
+
+  FakeWeb.register_uri(:delete, "http://example.com/posts/1",
+                       [{:string => "Post 1 deleted.", :status => ["200", "OK"]},
+                        {:string => "Post not found",  :status => ["404", "Not Found"]}])
+
+  Net::HTTP.start("example.com") do |req|
+    req.delete("/posts/1").body  # => "Post 1 deleted"
+    req.delete("/posts/1").body  # => "Post not found"
+    req.delete("/posts/1").body  # => "Post not found"
+  end
+
+=== Clearing registered URIs
+
+The FakeWeb registry is a singleton that lasts for the duration of your
+program, maintaining every fake response you register. If needed, you
+can clean out the registry and remove all registered URIs:
+
+  FakeWeb.clean_registry
+
+=== Blocking all real requests
+
+When you're using FakeWeb to replace _all_ of your requests, it's useful to
+catch when requests are made for unregistered URIs (unlike the default
+behavior, which is to pass those requests through to Net::HTTP as usual).
+
+  FakeWeb.allow_net_connect = false
+  Net::HTTP.get(URI.parse("http://example.com/"))
+  => raises FakeWeb::NetConnectNotAllowedError
+
+  FakeWeb.allow_net_connect = true
+  Net::HTTP.get(URI.parse("http://example.com/"))
+  => FakeWeb is bypassed and the response from a real request is returned
+
+This is handy when you want to make sure your tests are self-contained, or you
+want to catch the scenario when a URI is changed in implementation code
+without a corresponding test change.
+
+
+== More info
+
+FakeWeb lets you decouple your test environment from live services without
+modifying code or writing extensive stubs.
+
+In addition to the conceptual advantage of having idempotent request
+behaviour, FakeWeb makes tests run faster than if they were made to remote (or
+even local) web servers. It also makes it possible to run tests without a
+network connection or in situations where the server is behind a firewall or
+has host-based access controls.
+
+FakeWeb works with anything based on Net::HTTP--both higher-level wrappers,
+like OpenURI, as well as a ton of libraries for popular web services.
+
+
+== Known Issues
+
+* Request bodies are ignored, including PUT and POST parameters. If you need
+  different responses for different request bodies, you need to request
+  different URLs, and register different responses for each. (Query strings are
+  fully supported, though.) We're currently considering how the API should
+  change to add support for request bodies in 1.3.0. Your input would be really
+  helpful: see http://groups.google.com/group/fakeweb-users/browse_thread/thread/44d190a6b12e4273
+  for a discussion of some different options. Thanks!
+
+
+== Copyright
+
+Copyright 2006-2007 Blaine Cook
+
+Copyright 2008-2009 various contributors
+
+  FakeWeb is free software; you can redistribute it and/or modify it under the
+  terms of the GNU General Public License as published by the Free Software
+  Foundation; either version 2 of the License, or (at your option) any later
+  version.
+
+  FakeWeb is distributed in the hope that it will be useful, but WITHOUT ANY
+  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+  FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+  details.
+
+  You should have received a copy of the GNU General Public License along
+  with FakeWeb; if not, write to the Free Software Foundation, Inc., 51
+  Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+See <tt>LICENSE.txt</tt> for the full terms.

data/Rakefile

@@ -1,69 +1,63 @@
-# FakeWeb - Ruby Helper for Faking Web Requests
-# Copyright 2006 Blaine Cook <romeda@gmail.com>.
-# 
-# FakeWeb is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-# 
-# FakeWeb is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with FakeWeb; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
 require 'rubygems'
-Gem::manage_gems
-require 'rake/gempackagetask'
 require 'rake/testtask'
 require 'rake/rdoctask'
-require 'rcov/rcovtask'
-
-spec = Gem::Specification.new do |s| 
-  s.add_dependency('rake')
-  s.add_dependency('rcov')
-  s.name = "fakeweb" 
-  s.version = "1.1.2" 
-  s.author = "Blaine Cook" 
-  s.email = "romeda@gmail.com" 
-  s.homepage = "http://fakeweb.rubyforge.org/" 
-  s.platform = Gem::Platform::RUBY 
-  s.summary = "A test helper that makes it simple to test HTTP interaction" 
-  s.files = FileList["{test,lib}/**/*", '[A-Z]*'].exclude("rdoc", ".svn").to_a 
-  s.require_path = "lib" 
-  s.test_files = Dir.glob("test/test_*.rb")
-  s.has_rdoc = true 
-  s.extra_rdoc_files = ["README", "COPYING"] 
-  s.rubyforge_project = "fakeweb"
-end 
-
-Rake::GemPackageTask.new(spec) do |pkg| 
-  pkg.gem_spec = spec
-  pkg.need_tar = true 
-  pkg.need_zip = true
-end
 
-desc "Default Task"
-task :default => [:tests]
+task :default => :test
 
 desc "Run All Tests"
-Rake::TestTask.new :tests do |test|
+Rake::TestTask.new :test do |test|
   test.test_files = ["test/**/*.rb"]
   test.verbose = true
 end
 
 desc "Generate Documentation"
 Rake::RDocTask.new do |rdoc|
-  rdoc.main = "README"
+  rdoc.main = "README.rdoc"
   rdoc.rdoc_dir = "doc"
-  rdoc.rdoc_files.include("README", "COPYING", "lib/*.rb")
-  rdoc.title = "FakeWeb"
+  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'
 end
 
-Rcov::RcovTask.new do |t|
-  t.test_files = FileList['test/**/test*.rb'] 
-  t.rcov_opts << "--sort coverage"
+desc %{Update ".manifest" with the latest list of project filenames. Respect\
+.gitignore by excluding everything that git ignores. Update `files` and\
+`test_files` arrays in "*.gemspec" file if it's present.}
+task :manifest do
+  list = Dir['**/*'].sort
+  spec_file = Dir['*.gemspec'].first
+  list -= [spec_file] if spec_file
+
+  File.read('.gitignore').each_line do |glob|
+    glob = glob.chomp.sub(/^\//, '')
+    list -= Dir[glob]
+    list -= Dir["#{glob}/**/*"] if File.directory?(glob) and !File.symlink?(glob)
+    puts "excluding #{glob}"
+  end
+
+  if spec_file
+    spec = File.read spec_file
+    spec.gsub! /^(\s* s.(test_)?files \s* = \s* )( \[ [^\]]* \] | %w\( [^)]* \) )/mx do
+      assignment = $1
+      bunch = $2 ? list.grep(/^test\//) : list
+      '%s%%w(%s)' % [assignment, bunch.join(' ')]
+    end
+
+    File.open(spec_file,   'w') {|f| f << spec }
+  end
+  File.open('.manifest', 'w') {|f| f << list.join("\n") }
 end
+
+if RUBY_PLATFORM =~ /java/
+  puts "rcov support disabled (running under JRuby)."
+elsif RUBY_VERSION =~ /^1\.9/
+  puts "rcov support disabled (running under Ruby 1.9)"
+else
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    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

@@ -1,44 +1,68 @@
-# FakeWeb - Ruby Helper for Faking Web Requests
-# Copyright 2006 Blaine Cook <romeda@gmail.com>.
-# 
-# FakeWeb is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-# 
-# FakeWeb is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with FakeWeb; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-require 'fake_net_http'
 require 'singleton'
 
-module OpenURI #:nodoc: all
-  class HTTPError < StandardError; end;
-end
+require 'fake_web/ext/net_http'
+require 'fake_web/registry'
+require 'fake_web/response'
+require 'fake_web/responder'
+require 'fake_web/stub_socket'
 
 module FakeWeb
 
   # Resets the FakeWeb Registry. This will force all subsequent web requests to
   # behave as real requests.
-  def FakeWeb.clean_registry; FakeWeb::Registry.instance.clean_registry; end
+  def self.clean_registry
+    Registry.instance.clean_registry
+  end
+
+  # Enables or disables real HTTP connections for requests that don't match
+  # registered URIs.
+  #
+  # If you set <tt>FakeWeb.allow_net_connect = false</tt> and subsequently try
+  # to make a request to a URI you haven't registered with #register_uri, a
+  # NetConnectNotAllowedError will be raised. This is handy when you want to
+  # make sure your tests are self-contained, or want to catch the scenario
+  # when a URI is changed in implementation code without a corresponding test
+  # change.
+  #
+  # When <tt>FakeWeb.allow_net_connect = true</tt> (the default), requests to
+  # URIs not stubbed with FakeWeb are passed through to Net::HTTP.
+  def self.allow_net_connect=(allowed)
+    @allow_net_connect = allowed
+  end
+
+  # Enable pass-through to Net::HTTP by default.
+  self.allow_net_connect = true
+
+  # Returns +true+ if requests to URIs not registered with FakeWeb are passed
+  # through to Net::HTTP for normal processing (the default). Returns +false+
+  # if an exception is raised for these requests.
+  def self.allow_net_connect?
+    @allow_net_connect
+  end
 
-  # Register +uri+ to be handled according to +options+. +uri+ can be a
-  # +String+ or an +URI+ object. +options+ must be a +Hash+ that must contain
-  # any one of the following keys:
+  # This exception is raised if you set <tt>FakeWeb.allow_net_connect =
+  # false</tt> and subsequently try to make a request to a URI you haven't
+  # stubbed.
+  class NetConnectNotAllowedError < StandardError; end;
+
+  # call-seq:
+  #   FakeWeb.register_uri(method, uri, options)
+  #   FakeWeb.register_uri(uri, options)
+  #
+  # Register requests using the HTTP method specified by the symbol +method+ for
+  # +uri+ to be handled according to +options+. If no +method+ is specified, or
+  # you explicitly specify <tt>:any</tt>, the response will be reigstered for
+  # any request for +uri+. +uri+ can be a +String+ or a +URI+ object. +options+
+  # must be either a +Hash+ or an +Array+ of +Hashes+ (see below) that must
+  # contain any one of the following keys:
   #
   # <tt>:string</tt>::
   #   Takes a +String+ argument that is returned as the body of the response.
-  #     FakeWeb.register_uri('http://example.com/', :string => "Hello World!") 
+  #     FakeWeb.register_uri(:get, 'http://example.com/', :string => "Hello World!")
   # <tt>:file</tt>::
   #   Takes a valid filesystem path to a file that is slurped and returned as
   #   the body of the response.
-  #     FakeWeb.register_uri('http://example.com/', :file => "/tmp/my_response_body.txt")
+  #     FakeWeb.register_uri(:post, 'http://example.com/', :file => "/tmp/my_response_body.txt")
   # <tt>:response</tt>:: 
   #   Either an <tt>Net::HTTPResponse</tt>, an +IO+ or a +String+.
   # 
@@ -55,12 +79,20 @@ module FakeWeb
   #
   #   which can then be used in your test environment like so:
   #
-  #     FakeWeb.register_uri('http://www.example.com/', :response => 'response_for_www.example.com')
+  #     FakeWeb.register_uri(:get, 'http://www.example.com/', :response => 'response_for_www.example.com')
   #
   #   See the <tt>Net::HTTPResponse</tt>
   #   documentation[http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/classes/Net/HTTPResponse.html]
   #   for more information on creating custom response objects.
   # 
+  # +options+ may also be an +Array+ containing a list of the above-described +Hash+.
+  # In this case, FakeWeb will rotate through each provided response, you may optionally
+  # provide:
+  #
+  # <tt>:times</tt>::
+  #   The number of times this response will be used. Decremented by one each time it's called.
+  #   FakeWeb will use the final provided request indefinitely, regardless of its :times parameter.
+  # 
   # Two optional arguments are also accepted:
   #
   # <tt>:status</tt>::
@@ -73,161 +105,49 @@ module FakeWeb
   #   specified URL is requested. Any +Exception+ class is valid. Example:
   #     FakeWeb.register_uri('http://www.example.com/', :exception => Net::HTTPError)
   #
-  def FakeWeb.register_uri(uri, options); FakeWeb::Registry.instance.register_uri(uri, options); end
-
-  # Returns the faked Net::HTTPResponse object associated with +uri+.
-  def FakeWeb.response_for(uri, &block) #:nodoc: :yields: response
-    FakeWeb::Registry.instance.response_for(uri, &block)
-  end
-
-  # Checks for presence of +uri+ in the +FakeWeb+ registry.
-  def FakeWeb.registered_uri?(uri); FakeWeb::Registry.instance.registered_uri?(uri); end
-
-  class Registry #:nodoc:
-    include Singleton
-
-    attr_accessor :uri_map
-
-    def initialize
-      clean_registry
+  def self.register_uri(*args)
+    method = :any
+    case args.length
+    when 3 then method, uri, options = *args
+    when 2 then         uri, options = *args
+    else   raise ArgumentError.new("wrong number of arguments (#{args.length} for method = :any, uri, options)")
     end
 
-    def clean_registry
-      self.uri_map = {}
-    end
-
-    def register_uri(uri, options)
-      uri_map[normalize_uri(uri)] = FakeWeb::Responder.new(uri, options)
-    end
-
-    def registered_uri?(uri)
-      uri_map.has_key?(normalize_uri(uri))
-    end
-
-    def registered_uri(uri)
-      uri = normalize_uri(uri)
-      return uri_map[uri] if registered_uri?(uri)
-    end
-
-    def response_for(uri, &block)
-      return registered_uri(uri).response(&block)
-    end
-
-    private
-
-    def normalize_uri(uri)
-      case uri
-      when URI: uri
-      else
-        uri = 'http://' + uri unless uri.match('^https?://')
-        URI.parse(uri)
-      end
-    end
-  end
-
-  module Response #:nodoc:
-    def read_body(*args, &block)
-      yield @body if block_given?
-      @body
-    end
+    Registry.instance.register_uri(method, uri, options)
   end
 
-  class Responder #:nodoc:
-
-    attr_accessor :uri, :options
-
-    def initialize(uri, options)
-      self.uri = uri
-      self.options = options
-    end
-
-    def response(&block)
-      if has_baked_response?
-        response = baked_response
-      else
-        code, msg = meta_information
-        response = Net::HTTPResponse.send(:response_class, code.to_s).new(uri, code.to_s, msg)
-        response.instance_variable_set(:@body, content)
-      end
-      response.instance_variable_set(:@read, true)
-      response.extend FakeWeb::Response
-
-      optionally_raise(response)
-
-      yield response if block_given?
-
-      response
-    end
-
-    private
-
-    def content
-      [ :file, :string ].each do |map_option|
-        next unless options.has_key?(map_option)
-        return self.send("#{map_option}_response", options[map_option])
-      end
-
-      return ''
-    end
-
-    def file_response(path)
-      IO.readlines(path).join("\n")
-    end
-
-    def string_response(string)
-      string
-    end
-
-    def baked_response
-      resp = case options[:response]
-      when Net::HTTPResponse: options[:response]
-      when String
-        socket = Net::BufferedIO.new(options[:response])
-        r = Net::HTTPResponse.read_new(socket)
-        r.instance_eval { @header['transfer-encoding'] = nil }
-        r.reading_body(socket, true) {}
-        r
-      else raise StandardError, "Handler unimplemented for response #{options[:response]}"
-      end
-    end
-
-    def has_baked_response?
-      options.has_key?(:response)
-    end
-
-    def optionally_raise(response)
-      return unless options.has_key?(:exception)
-      ex_alloc = options[:exception].allocate
-      ex_instance = case ex_alloc
-      when Net::HTTPError, OpenURI::HTTPError: options[:exception].new('Exception from FakeWeb', response)
-      else options[:exception].new
-      end
-      raise ex_instance
+  # call-seq:
+  #   FakeWeb.response_for(method, uri)
+  #   FakeWeb.response_for(uri)
+  #
+  # Returns the faked Net::HTTPResponse object associated with +uri+.
+  def self.response_for(*args, &block) #:nodoc: :yields: response
+    method = :any
+    case args.length
+    when 2 then method, uri = args
+    when 1 then         uri = args.first
+    else   raise ArgumentError.new("wrong number of arguments (#{args.length} for method = :any, uri)")
     end
 
-    def meta_information
-      if options.has_key?(:status); options[:status]
-      else; [ 200, 'OK' ]
-      end
-    end
+    Registry.instance.response_for(method, uri, &block)
   end
 
-  class SocketDelegator #:nodoc:
-
-    def initialize(delegate=nil)
-      @delegate = nil
-    end
-
-    def method_missing(method, *args, &block)
-      return @delegate.send(method, *args, &block) if @delegate
-      return self.send("my_#{method}", *args, &block)
-    end
-
-    def my_closed?
-      @closed ||= true
-    end
-
-    def my_readuntil(*args)
-    end
+  # call-seq:
+  #   FakeWeb.registered_uri?(method, uri)
+  #   FakeWeb.registered_uri?(uri)
+  #
+  # Returns true if +uri+ is registered with FakeWeb. You can optionally
+  # specify +method+ to limit the search to a certain HTTP method (or use
+  # <tt>:any</tt> to explicitly check against any method).
+  def self.registered_uri?(*args)
+    method = :any
+    case args.length
+    when 2 then method, uri = args
+    when 1 then         uri = args.first
+    else   raise ArgumentError.new("wrong number of arguments (#{args.length} for method = :any, uri)")
+    end
+
+    Registry.instance.registered_uri?(method, uri)
   end
-end
+
+end