chrisk-fakeweb 1.1.2.4 → 1.1.2.5

data/CHANGELOG

@@ -1,48 +1,59 @@
 fakeweb (development)
 
-  [ Chris Kampmeier ]
-  * add support for Net::HTTP's undocumented full-URI request style (fixes
-    URI::InvalidURIErrors that you might see in older libraries)
-  * 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)
-  * add support for ports in URLs, so that http://example.com/ and
-    http://example.com:3000/ are not the same
-  * fix for non-faked SSL requests failing with "Unable to create local socket"
-  * update Rakefile to fix warning about deprecated code
-
--- Chris Kampmeier <chris@kampers.net>  Mon,  13 Oct 2008 02:46:12 -0700
+* 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

@@ -1,53 +1,73 @@
 = FakeWeb
 
-A Helper for Faking Web Requests
+FakeWeb is a helper for faking web requests. It works at a global level, without
+modifying code or writing extensive stubs.
 
 = Examples
 
-  require 'test/unit'
-  require 'fake_web'
-  require 'open-uri'
-
-  class FakeWebExampleTest < Test::Unit::TestCase
-    def test_request
-      FakeWeb.register_uri('http://example.com/test_me', :string => "Hello World!")
-      content = Net::HTTP.get(URI.parse('http://example.com/test_me'))
-      assert_equal "Hello World!", content
-    end
-
-    def test_request_with_response
-      FakeWeb.register_uri('http://www.google.com/', :response => `curl -is http://www.google.com/`)
-      Net::HTTP.start('www.google.com') do |req|
-        response = req.get('/')
-        if response.code == 200
-          assert_equal "OK", response.message
-          assert response.body.include?('<title>Google')
-        elsif response.code == 302
-          # Google redirects foreign sites to ccTLDs.
-          assert_equal "Found", response.message
-          assert response.body.include?('The document has moved')
-        end
-      end
-    end
-
-    def test_request_with_custom_status
-      FakeWeb.register_uri('http://example.com/', :string => "Nothing to be found 'round here",
-                                                  :status => ['404', 'Not Found'])
-      Net::HTTP.start('example.com') do |req|
-        response = req.get('/')
-        assert_equal "404", response.code
-        assert_equal "Not Found", response.message
-        assert_equal "Nothing to be found 'round here", response.body
-      end
-    end
-
-    def test_open_uri
-      FakeWeb.register_uri('http://example.com/', :string => "Hello, World!")
-      content = open('http://example.com/').string
-      assert_equal "Hello, World!", content
-    end
+== Using a string response
+
+  FakeWeb.register_uri("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('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('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
+
+== 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('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
 
+== Requesting with OpenURI
+
+  FakeWeb.register_uri('http://example.com/', :string => "Hello, World!")
+
+  open('http://example.com/').string
+  => "Hello, World!"
+
+== Clearing registered URIs
+
+The FakeWeb registry is a singleton that lasts for the duration of your
+program, maintaining every fake responses you register. If needed, you
+can clean out the registry and remove all registered URIs:
+
+  FakeWeb.clean_registry
+
 
 = Description
 

data/Rakefile

@@ -16,40 +16,14 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 require 'rubygems'
-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.4"
-  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.rdoc", "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
@@ -58,11 +32,41 @@ desc "Generate Documentation"
 Rake::RDocTask.new do |rdoc|
   rdoc.main = "README.rdoc"
   rdoc.rdoc_dir = "doc"
-  rdoc.rdoc_files.include("README.rdoc", "COPYING", "lib/*.rb")
+  rdoc.rdoc_files.include("README.rdoc", "COPYING", "CHANGELOG", "lib/*.rb")
   rdoc.title = "FakeWeb"
 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.}
+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

data/lib/fake_net_http.rb

@@ -23,6 +23,8 @@ module Net #:nodoc:
 
   class BufferedIO #:nodoc:
     def initialize( io, debug_output = nil )
+      @read_timeout = 60
+      @rbuf = ''
       @debug_output = debug_output
       @io = case io
       when Socket, OpenSSL::SSL::SSLSocket, IO: io
@@ -30,16 +32,8 @@ module Net #:nodoc:
         File.exists?(io) ?  File.open(io, "r") : StringIO.new(io)
       end
       raise "Unable to create local socket" unless @io
-      connect
     end
 
-    def connect(*args)
-      @rbuf = ''
-    end
-
-    def rbuf_fill
-      @rbuf << @io.sysread(1024)
-    end
   end
   
   class HTTP #:nodoc:
@@ -63,8 +57,13 @@ module Net #:nodoc:
         @socket = Net::HTTP.socket_type.new
         return FakeWeb.response_for(uri, &block)
       else
-        original_net_http_connect
-        return original_net_http_request(req, body, &block)
+        if FakeWeb.allow_net_connect?
+          original_net_http_connect
+          return original_net_http_request(req, body, &block)
+        else
+          expected = FakeWeb::Registry.instance.uri_map.keys
+          raise "unexpected HTTP #{req.method} to #{uri}\n-- expected one of #{expected.inspect}"
+        end
       end
     end
 

data/lib/fake_web.rb

@@ -26,11 +26,39 @@ 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, an
+  # exception 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 registered 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:
+  # +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:
   #
   # <tt>:string</tt>::
   #   Takes a +String+ argument that is returned as the body of the response.
@@ -61,6 +89,14 @@ module FakeWeb
   #   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,15 +109,19 @@ 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
+  def self.register_uri(uri, options)
+    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)
+  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 FakeWeb.registered_uri?(uri); FakeWeb::Registry.instance.registered_uri?(uri); end
+  def self.registered_uri?(uri)
+    Registry.instance.registered_uri?(uri)
+  end
 
   class Registry #:nodoc:
     include Singleton
@@ -97,7 +137,9 @@ module FakeWeb
     end
 
     def register_uri(uri, options)
-      uri_map[normalize_uri(uri)] = FakeWeb::Responder.new(uri, options)
+      uri_map[normalize_uri(uri)] = [*[options]].flatten.collect { |option|
+        FakeWeb::Responder.new(uri, option, option[:times])
+      }
     end
 
     def registered_uri?(uri)
@@ -110,7 +152,18 @@ module FakeWeb
     end
 
     def response_for(uri, &block)
-      return registered_uri(uri).response(&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
@@ -127,7 +180,7 @@ module FakeWeb
     end
 
     def sort_query_params(query)
-      return nil if query.nil?
+      return nil if query.nil? or query.empty?
       query.split('&').sort.join('&')
     end
   end
@@ -141,11 +194,12 @@ module FakeWeb
 
   class Responder #:nodoc:
 
-    attr_accessor :uri, :options
+    attr_accessor :uri, :options, :times
 
-    def initialize(uri, options)
+    def initialize(uri, options, times)
       self.uri = uri
       self.options = options
+      self.times = times ? times : 1
     end
 
     def response(&block)