chrisk-fakeweb 1.1.2.5 → 1.1.2.6

data/CHANGELOG

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

data/README.rdoc

@@ -1,11 +1,24 @@
 = FakeWeb
 
-FakeWeb is a helper for faking web requests. It works at a global level, without
-modifying code or writing extensive stubs.
+FakeWeb is a helper for faking web requests in Ruby. It works at a global
+level, without modifying code or writing extensive stubs.
+
+= 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):
+
+  sudo gem install chrisk-fakeweb --source http://gems.github.com
 
 = Examples
 
-== Using a string response
+Start by requiring FakeWeb:
+
+  require 'rubygems'
+  require 'fake_web'
+
+== Registering basic string responses
 
   FakeWeb.register_uri("http://example.com/test1", :string => "Hello World!")
 
@@ -53,53 +66,62 @@ option for that response.)
     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
+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
 
-= Description
+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 is a helper for faking web requests. This makes testing easier,
-because you can decouple your test environment from live services without
-modifying code. It allows for a range of request behaviour, from simple
-stubbing of HTTP responses to re-playing complete recorded responses.
+  FakeWeb.allow_net_connect = false
+  Net::HTTP.get(URI.parse('http://example.com/'))
+  => raises FakeWeb::NetConnectNotAllowedError
 
-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.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.
 
-FakeWeb is tested with
-Net::HTTP[http://www.ruby-doc.org/stdlib/libdoc/net/http/rdoc/index.html] and
-OpenURI[http://www.ruby-doc.org/stdlib/libdoc/open-uri/rdoc/]. It should work
-with any web client library that uses Net::HTTP for its underlying requests
-(e.g., Flickr.rb[http://redgreenblu.com/flickr/],
-Ruby/Amazon[http://www.caliban.org/ruby/ruby-amazon.shtml],
-soap4r[http://dev.ctor.org/soap4r/], etc.)
 
 = 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.
+* Requests are only stubbed at the URI level, with no respect to HTTP method.
+
+* 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.)
+
 
 = Copyright
 
-FakeWeb - Ruby Helper for Faking Web Requests
-Copyright 2006 Blaine Cook <romeda@gmail.com>.
+Copyright 2006-2007 Blaine Cook
+
+Copyright 2008 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

data/Rakefile

@@ -33,7 +33,9 @@ Rake::RDocTask.new do |rdoc|
   rdoc.main = "README.rdoc"
   rdoc.rdoc_dir = "doc"
   rdoc.rdoc_files.include("README.rdoc", "COPYING", "CHANGELOG", "lib/*.rb")
-  rdoc.title = "FakeWeb"
+  rdoc.title = "FakeWeb API Documentation"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.options << '--charset' << 'utf-8'
 end
 
 Rcov::RcovTask.new do |t|

data/lib/fake_net_http.rb

@@ -1,16 +1,16 @@
 # 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
@@ -19,55 +19,55 @@ require 'net/http'
 require 'net/https'
 require 'stringio'
 
-module Net #:nodoc:
+module Net  #:nodoc: all
 
-  class BufferedIO #:nodoc:
-    def initialize( io, debug_output = nil )
+  class BufferedIO
+    def initialize(io, debug_output = nil)
       @read_timeout = 60
       @rbuf = ''
       @debug_output = debug_output
+
       @io = case io
-      when Socket, OpenSSL::SSL::SSLSocket, IO: io
+      when Socket, OpenSSL::SSL::SSLSocket, IO
+        io
       when String
-        File.exists?(io) ?  File.open(io, "r") : StringIO.new(io)
+        File.exists?(io) ? File.open(io, "r") : StringIO.new(io)
       end
       raise "Unable to create local socket" unless @io
     end
-
   end
-  
-  class HTTP #:nodoc:
 
-    def HTTP.socket_type #:nodoc:
+
+  class HTTP
+    def self.socket_type
       FakeWeb::SocketDelegator
     end
 
     alias :original_net_http_request :request
     alias :original_net_http_connect :connect
-    
-    def request(req, body = nil, &block)
-      prot = use_ssl ? "https" : "http"
 
-      path = req.path
-      path = URI.parse(req.path).request_uri if req.path =~ /^http/
+    def request(request, body = nil, &block)
+      protocol = use_ssl ? "https" : "http"
 
-      uri = "#{prot}://#{self.address}:#{self.port}#{path}"
+      path = request.path
+      path = URI.parse(request.path).request_uri if request.path =~ /^http/
+
+      uri = "#{protocol}://#{self.address}:#{self.port}#{path}"
 
       if FakeWeb.registered_uri?(uri)
         @socket = Net::HTTP.socket_type.new
-        return FakeWeb.response_for(uri, &block)
+        FakeWeb.response_for(uri, &block)
+      elsif FakeWeb.allow_net_connect?
+        original_net_http_connect
+        original_net_http_request(request, body, &block)
       else
-        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
+        raise FakeWeb::NetConnectNotAllowedError,
+              "Real HTTP connections are disabled. Unregistered URI: #{uri}"
       end
     end
 
     def connect
     end
   end
+
 end

data/lib/fake_web.rb

@@ -34,13 +34,14 @@ module FakeWeb
   # 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.
+  # 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 registered with FakeWeb are passed through to Net::HTTP.
+  # URIs not stubbed with FakeWeb are passed through to Net::HTTP.
   def self.allow_net_connect=(allowed)
     @allow_net_connect = allowed
   end
@@ -55,6 +56,12 @@ module FakeWeb
     @allow_net_connect
   end
 
+  # 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;
+
+
   # 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 
@@ -170,7 +177,7 @@ module FakeWeb
 
     def normalize_uri(uri)
       case uri
-      when URI: uri
+      when URI then uri
       else
         uri = 'http://' + uri unless uri.match('^https?://')
         parsed_uri = URI.parse(uri)
@@ -241,7 +248,7 @@ module FakeWeb
 
     def baked_response
       resp = case options[:response]
-      when Net::HTTPResponse: options[:response]
+      when Net::HTTPResponse then options[:response]
       when String
         socket = Net::BufferedIO.new(options[:response])
         r = Net::HTTPResponse.read_new(socket)
@@ -260,7 +267,8 @@ module FakeWeb
       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)
+      when Net::HTTPError, OpenURI::HTTPError
+        options[:exception].new('Exception from FakeWeb', response)
       else options[:exception].new
       end
       raise ex_instance

data/test/test_allow_net_connect.rb

@@ -2,39 +2,36 @@ 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
-    original_value = FakeWeb.allow_net_connect?
     FakeWeb.allow_net_connect = true
-
     setup_expectations_for_real_apple_hot_news_request
     Net::HTTP.get(URI.parse("http://images.apple.com/main/rss/hotnews/hotnews.rss"))
-
-    FakeWeb.allow_net_connect = original_value
   end
 
   def test_raises_for_unregistered_requests_when_allow_net_connect_is_false
-    original_value = FakeWeb.allow_net_connect?
     FakeWeb.allow_net_connect = false
-
-    assert_raise RuntimeError do
+    exception = assert_raise FakeWeb::NetConnectNotAllowedError do
       Net::HTTP.get(URI.parse('http://example.com/'))
     end
-
-    FakeWeb.allow_net_connect = original_value
   end
 
   def test_question_mark_method_returns_true_after_setting_allow_net_connect_to_true
-    original_value = FakeWeb.allow_net_connect?
     FakeWeb.allow_net_connect = true
     assert FakeWeb.allow_net_connect?
-    FakeWeb.allow_net_connect = original_value
   end
 
   def test_question_mark_method_returns_false_after_setting_allow_net_connect_to_false
-    original_value = FakeWeb.allow_net_connect?
     FakeWeb.allow_net_connect = false
     assert !FakeWeb.allow_net_connect?
-    FakeWeb.allow_net_connect = original_value
   end
 
   def test_allow_net_connect_is_true_by_default

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chrisk-fakeweb
 version: !ruby/object:Gem::Version 
-  version: 1.1.2.5
+  version: 1.1.2.6
 platform: ruby
 authors: 
 - Blaine Cook
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-25 00:00:00 -08:00
+date: 2008-12-31 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -66,7 +66,7 @@ rubyforge_project:
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: A test helper that makes it simple to test HTTP interaction
+summary: A tool for faking responses to HTTP requests
 test_files: 
 - test/fixtures
 - test/fixtures/test_example.txt