chrisk-fakeweb 1.1.2.6 → 1.1.2.7

data/CHANGELOG

@@ -1,5 +1,26 @@
 fakeweb (development)
 
+* 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

data/README.rdoc

@@ -3,52 +3,79 @@
 FakeWeb is a helper for faking web requests in Ruby. It works at a global
 level, without modifying code or writing extensive stubs.
 
-= Installation
+
+== Installation
 
 This fork of Blaine Cook's original code has lots of fixes, stability
-improvements, and a few new features. To get it, install the latest gem
-directly from GitHub (currently 1.1.2.6):
+improvements, and a few new features. It also has new support for Ruby 1.9.1
+and JRuby. To get it, install the latest gem directly from GitHub (currently
+1.1.2.7):
 
   sudo gem install chrisk-fakeweb --source http://gems.github.com
 
-= Examples
+
+== Help and discussion
+
+There's a brand new mailing list at http://groups.google.com/group/fakeweb-users.
+
+
+== Development Notes
+
+We're currently considering how the API should change to add support for
+request bodies (see Known Issues below). 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!
+
+
+== Examples
 
 Start by requiring FakeWeb:
 
   require 'rubygems'
   require 'fake_web'
 
-== Registering basic string responses
+=== Registering basic string responses
 
-  FakeWeb.register_uri("http://example.com/test1", :string => "Hello World!")
+  FakeWeb.register_uri(:get, "http://example.com/test1", :string => "Hello World!")
 
-  Net::HTTP.get(URI.parse('http://example.com/test1'))
+  Net::HTTP.get(URI.parse("http://example.com/test1"))
   => "Hello World!"
 
-  Net::HTTP.get(URI.parse('http://example.com/test2'))
+  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
+=== Replaying a recorded response
 
   page = `curl -is http://www.google.com/`
-  FakeWeb.register_uri('http://www.google.com/', :response => page)
+  FakeWeb.register_uri(:get, "http://www.google.com/", :response => page)
 
-  Net::HTTP.get(URI.parse('http://www.google.com/'))
+  Net::HTTP.get(URI.parse("http://www.google.com/"))
   # => Full response, including headers
 
-== Adding a custom status to the response
+=== Adding a custom status to the response
 
-  FakeWeb.register_uri('http://example.com/', :string => "Nothing to be found 'round here",
-                                              :status => ["404", "Not Found"])
+  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('/')
+  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
 
-== Rotating responses
+=== 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
@@ -56,17 +83,17 @@ 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('http://example.com/posts/1',
+  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"
+  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
+=== 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
@@ -74,25 +101,25 @@ can clean out the registry and remove all registered URIs:
 
   FakeWeb.clean_registry
 
-== Blocking all real requests
+=== 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/'))
+  Net::HTTP.get(URI.parse("http://example.com/"))
   => raises FakeWeb::NetConnectNotAllowedError
 
   FakeWeb.allow_net_connect = true
-  Net::HTTP.get(URI.parse('http://example.com/'))
+  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
+== More info
 
 FakeWeb lets you decouple your test environment from live services without
 modifying code or writing extensive stubs.
@@ -107,32 +134,32 @@ 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
-
-* Requests are only stubbed at the URI level, with no respect to HTTP method.
+== Known Issues
 
-* Similarly, 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.)
+* 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.)
 
 
-= Copyright
+== Copyright
 
 Copyright 2006-2007 Blaine Cook
 
-Copyright 2008 various contributors
+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 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.
 
-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
 
-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,24 +1,6 @@
-# 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'
 require 'rake/testtask'
 require 'rake/rdoctask'
-require 'rcov/rcovtask'
 
 task :default => :test
 
@@ -32,19 +14,12 @@ desc "Generate Documentation"
 Rake::RDocTask.new do |rdoc|
   rdoc.main = "README.rdoc"
   rdoc.rdoc_dir = "doc"
-  rdoc.rdoc_files.include("README.rdoc", "COPYING", "CHANGELOG", "lib/*.rb")
+  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"
-  t.rcov_opts << "--exclude gems"
-  t.rcov_opts << "--no-validator-links"
-end
-
 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.}
@@ -72,3 +47,17 @@ task :manifest do
   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,26 +1,10 @@
-# 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/socket_delegator'
 
 module FakeWeb
 
@@ -61,19 +45,24 @@ module FakeWeb
   # stubbed.
   class NetConnectNotAllowedError < StandardError; end;
 
-
-  # Register +uri+ to be handled according to +options+. +uri+ can be a
-  # +String+ or an +URI+ object. +options+ must be either a +Hash+ or 
-  # an +Array+ of +Hashes+ (see below) that must contain any one of the 
-  # following keys:
+  # 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+.
   # 
@@ -90,7 +79,7 @@ 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]
@@ -116,187 +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 self.register_uri(uri, options)
-    Registry.instance.register_uri(uri, options)
-  end
-
-  # Returns the faked Net::HTTPResponse object associated with +uri+.
-  def self.response_for(uri, &block) #:nodoc: :yields: response
-    Registry.instance.response_for(uri, &block)
-  end
-
-  # Checks for presence of +uri+ in the +FakeWeb+ registry.
-  def self.registered_uri?(uri)
-    Registry.instance.registered_uri?(uri)
-  end
-
-  class Registry #:nodoc:
-    include Singleton
-
-    attr_accessor :uri_map
-
-    def initialize
-      clean_registry
-    end
-
-    def clean_registry
-      self.uri_map = {}
-    end
-
-    def register_uri(uri, options)
-      uri_map[normalize_uri(uri)] = [*[options]].flatten.collect { |option|
-        FakeWeb::Responder.new(uri, option, option[:times])
-      }
+  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 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)
-      responses = registered_uri(uri)
-
-      next_response = responses.last
-      responses.each { |response|
-        if response.times and response.times > 0
-          response.times -= 1
-          next_response = response
-          break
-        end
-      }
-
-      return next_response.response(&block)
-    end
-
-    private
-
-    def normalize_uri(uri)
-      case uri
-      when URI then uri
-      else
-        uri = 'http://' + uri unless uri.match('^https?://')
-        parsed_uri = URI.parse(uri)
-        parsed_uri.query = sort_query_params(parsed_uri.query)
-        parsed_uri
-      end
-    end
-
-    def sort_query_params(query)
-      return nil if query.nil? or query.empty?
-      query.split('&').sort.join('&')
-    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, :times
-
-    def initialize(uri, options, times)
-      self.uri = uri
-      self.options = options
-      self.times = times ? times : 1
-    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 then 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