fakeweb 1.2.3 → 1.2.4

data/CHANGELOG

@@ -1,3 +1,25 @@
+fakeweb (1.2.4)
+
+* add experimental support for matching URIs via regular expressions
+  [Jacqui Maher, Tiago Albineli Motta, Peter Wagene]
+
+* fix an exception when registering with the :response option and a string that
+  is the same as the name of a directory in the current path [Chris Kampmeier]
+
+* DEPRECATION: Calling FakeWeb.register_uri with a :string or :file option is
+  now deprecated. Both options have been replaced with a unified :body option,
+  since they supply the response body (as opposed to :response, which supplies
+  the full response including headers) [Chris Kampmeier]
+
+* add support for specifying HTTP headers as options to FakeWeb.register_uri
+  when using the :string or :file response types, since those methods only
+  specify a response body [David Michael, Chris Kampmeier]
+
+* DEPRECATION: Calling FakeWeb.register_uri and FakeWeb.registered_uri? without
+  an HTTP method as the first argument is now deprecated. To match against any
+  HTTP method (the pre-1.2.0 behavior), use :any [Chris Kampmeier]
+
+
 fakeweb (1.2.3)
 
 * fix the #http_version of :file and :string responses, which was returning the

data/README.rdoc

@@ -34,7 +34,7 @@ Start by requiring FakeWeb:
 
 === Registering basic string responses
 
-  FakeWeb.register_uri(:get, "http://example.com/test1", :string => "Hello World!")
+  FakeWeb.register_uri(:get, "http://example.com/test1", :body => "Hello World!")
 
   Net::HTTP.get(URI.parse("http://example.com/test1"))
   => "Hello World!"
@@ -42,6 +42,9 @@ Start by requiring FakeWeb:
   Net::HTTP.get(URI.parse("http://example.com/test2"))
   => FakeWeb is bypassed and the response from a real request is returned
 
+You can also call <tt>register_uri</tt> with a regular expression, to match
+more than one URI.
+
 === Replaying a recorded response
 
   page = `curl -is http://www.google.com/`
@@ -52,7 +55,7 @@ Start by requiring FakeWeb:
 
 === Adding a custom status to the response
 
-  FakeWeb.register_uri(:get, "http://example.com/", :string => "Nothing to be found 'round here",
+  FakeWeb.register_uri(:get, "http://example.com/", :body => "Nothing to be found 'round here",
                                                     :status => ["404", "Not Found"])
 
   Net::HTTP.start("example.com") do |req|
@@ -64,14 +67,13 @@ Start by requiring FakeWeb:
 
 === Responding to any HTTP method
 
-  FakeWeb.register_uri(:any, "http://example.com", :string => "response for any HTTP method")
+  FakeWeb.register_uri(:any, "http://example.com", :body => "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.)
++method+ argument above; this syntax is now deprecated.)
 
 === Rotating responses
 
@@ -82,8 +84,8 @@ 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"]}])
+                       [{:body => "Post 1 deleted.", :status => ["200", "OK"]},
+                        {:body => "Post not found",  :status => ["404", "Not Found"]}])
 
   Net::HTTP.start("example.com") do |req|
     req.delete("/posts/1").body  # => "Post 1 deleted"
@@ -96,8 +98,8 @@ option for that response.)
 You can stub requests that use basic authentication with +userinfo+ strings in
 the URIs:
 
-  FakeWeb.register_uri("http://example.com/secret", :string => "Unauthorized", :status => ["401", "Unauthorized"])
-  FakeWeb.register_uri("http://user:pass@example.com/secret", :string => "Authorized")
+  FakeWeb.register_uri(:get, "http://example.com/secret", :body => "Unauthorized", :status => ["401", "Unauthorized"])
+  FakeWeb.register_uri(:get, "http://user:pass@example.com/secret", :body => "Authorized")
 
   Net::HTTP.start("example.com") do |http|
     req = Net::HTTP::Get.new("/secret")
@@ -132,6 +134,15 @@ 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.
 
+=== Specifying HTTP response headers
+
+When you register a response using the <tt>:body</tt> option, you're only
+setting the body of the response. If you want to add headers to these responses,
+simply add the header as an option to +register_uri+:
+
+  FakeWeb.register_uri(:get, "http://example.com/hello.txt", :body => "Hello", :content_type => "text/plain")
+
+This sets the "Content-Type" header in the response.
 
 == More info
 

data/lib/fake_web.rb

@@ -47,24 +47,22 @@ module FakeWeb
 
   # 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:
+  # Register requests using the HTTP method specified by the symbol +method+
+  # for +uri+ to be handled according to +options+. If you specify the method
+  # <tt>:any</tt>, the response will be reigstered for any request for +uri+.
+  # +uri+ can be a +String+, +URI+, or +Regexp+ object. +options+ must be either
+  # a +Hash+ or an +Array+ of +Hashes+ (see below), which must contain one of
+  # these two keys:
   #
-  # <tt>:string</tt>::
-  #   Takes a +String+ argument that is returned as the body of the response.
-  #     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(:post, 'http://example.com/', :file => "/tmp/my_response_body.txt")
+  # <tt>:body</tt>::
+  #   A string which is used as the body of the response. If the string refers
+  #   to a valid filesystem path, the contents of that file will be read and used
+  #   as the body of the response instead. (This used to be two options,
+  #   <tt>:string</tt> and <tt>:file</tt>, respectively. These are now deprecated.)
   # <tt>:response</tt>:: 
-  #   Either an <tt>Net::HTTPResponse</tt>, an +IO+ or a +String+.
+  #   Either an <tt>Net::HTTPResponse</tt>, an +IO+, or a +String+ which is used
+  #   as the full response for the request.
   # 
   #   The easier way by far is to pass the <tt>:response</tt> option to
   #   +register_uri+ as a +String+ or an (open for reads) +IO+ object which
@@ -85,9 +83,9 @@ 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:
+  # +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.
@@ -99,55 +97,70 @@ module FakeWeb
   #   Passing <tt>:status</tt> as a two-value array will set the response code
   #   and message. The defaults are <tt>200</tt> and <tt>OK</tt>, respectively.
   #   Example:
-  #     FakeWeb.register_uri('http://www.example.com/', :response => "Go away!", :status => [ 404, "Not Found" ])
+  #     FakeWeb.register_uri("http://www.example.com/", :body => "Go away!", :status => [404, "Not Found"])
   # <tt>:exception</tt>::
   #   The argument passed via <tt>:exception</tt> will be raised when the
   #   specified URL is requested. Any +Exception+ class is valid. Example:
   #     FakeWeb.register_uri('http://www.example.com/', :exception => Net::HTTPError)
   #
+  # If you're using the <tt>:body</tt> response type, you can pass additional
+  # options to specify the HTTP headers to be used in the response. Example:
+  #
+  #   FakeWeb.register_uri(:get, "http://example.com/index.txt", :body => "Hello", :content_type => "text/plain")
   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)")
+    when 3
+      Registry.instance.register_uri(*args)
+    when 2
+      print_missing_http_method_deprecation_warning(*args)
+      Registry.instance.register_uri(:any, *args)
+    else
+      raise ArgumentError.new("wrong number of arguments (#{args.length} for 3)")
     end
-
-    Registry.instance.register_uri(method, uri, options)
   end
 
   # call-seq:
   #   FakeWeb.response_for(method, uri)
-  #   FakeWeb.response_for(uri)
   #
-  # Returns the faked Net::HTTPResponse object associated with +uri+.
+  # Returns the faked Net::HTTPResponse object associated with +method+ and +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)")
+    when 2
+      Registry.instance.response_for(*args, &block)
+    when 1
+      print_missing_http_method_deprecation_warning(*args)
+      Registry.instance.response_for(:any, *args, &block)
+    else
+      raise ArgumentError.new("wrong number of arguments (#{args.length} for 2)")
     end
-
-    Registry.instance.response_for(method, uri, &block)
   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).
+  # Returns true if a +method+ request for +uri+ is registered with FakeWeb.
+  # Specify a method of <tt>:any</tt> to check for against all HTTP methods.
   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)")
+    when 2
+      Registry.instance.registered_uri?(*args)
+    when 1
+      print_missing_http_method_deprecation_warning(*args)
+      Registry.instance.registered_uri?(:any, *args)
+    else
+      raise ArgumentError.new("wrong number of arguments (#{args.length} for 2)")
     end
-
-    Registry.instance.registered_uri?(method, uri)
   end
 
-end
+  private
+
+  def self.print_missing_http_method_deprecation_warning(*args)
+    method = caller.first.match(/`(.*?)'/)[1]
+    new_args = args.map { |a| a.inspect }.unshift(":any")
+    new_args.last.gsub!(/^\{|\}$/, "").gsub!("=>", " => ") if args.last.is_a?(Hash)
+    $stderr.puts
+    $stderr.puts "Deprecation warning: FakeWeb requires an HTTP method argument (or use :any). Try this:"
+    $stderr.puts "  FakeWeb.#{method}(#{new_args.join(', ')})"
+    $stderr.puts "Called at #{caller[1]}"
+  end
+end

data/lib/fake_web/ext/net_http.rb

@@ -15,7 +15,7 @@ module Net  #:nodoc: all
       when Socket, OpenSSL::SSL::SSLSocket, IO
         io
       when String
-        if !io.include?("\0") && File.exists?(io)
+        if !io.include?("\0") && File.exists?(io) && !File.directory?(io)
           File.open(io, "r")
         else
           StringIO.new(io)
@@ -56,6 +56,8 @@ 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://|
         raise FakeWeb::NetConnectNotAllowedError,
               "Real HTTP connections are disabled. Unregistered request: #{request.method} #{uri}"
       end

data/lib/fake_web/registry.rb

@@ -2,7 +2,7 @@ module FakeWeb
   class Registry #:nodoc:
     include Singleton
 
-    attr_accessor :uri_map
+    attr_accessor :uri_map, :pattern_map
 
     def initialize
       clean_registry
@@ -12,17 +12,29 @@ module FakeWeb
       self.uri_map = Hash.new do |hash, key|
         hash[key] = Hash.new(&hash.default_proc)
       end
+      self.pattern_map = []
     end
 
     def register_uri(method, uri, options)
-      uri_map[normalize_uri(uri)][method] = [*[options]].flatten.collect do |option|
-        FakeWeb::Responder.new(method, uri, option, option[:times])
+      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 }
+
       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)
+      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)
@@ -30,8 +42,12 @@ module FakeWeb
       registered = registered_uri?(method, uri)
       if registered && uri_map[uri].has_key?(method)
         uri_map[uri][method]
-      elsif registered
+      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
@@ -53,13 +69,28 @@ 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 }
+    end
+
+    def pattern_map_match(method, uri)
+      pattern_map_matches(method, uri).first
+    end
+
     private
 
     def normalize_uri(uri)
       normalized_uri =
         case uri
         when URI then uri
-        else
+        when String
           uri = 'http://' + uri unless uri.match('^https?://')
           URI.parse(uri)
         end
@@ -76,4 +107,4 @@ module FakeWeb
     end
 
   end
-end
+end

data/lib/fake_web/responder.rb

@@ -2,12 +2,18 @@ module FakeWeb
   class Responder #:nodoc:
 
     attr_accessor :method, :uri, :options, :times
+    KNOWN_OPTIONS = [:body, :exception, :response, :status].freeze
 
     def initialize(method, uri, options, times)
       self.method = method
       self.uri = uri
       self.options = options
       self.times = times ? times : 1
+
+      if options.has_key?(:file) || options.has_key?(:string)
+        print_file_string_options_deprecation_warning
+        options[:body] = options.delete(:file) || options.delete(:string)
+      end
     end
 
     def response(&block)
@@ -16,7 +22,8 @@ module FakeWeb
       else
         code, msg = meta_information
         response = Net::HTTPResponse.send(:response_class, code.to_s).new("1.0", code.to_s, msg)
-        response.instance_variable_set(:@body, content)
+        response.instance_variable_set(:@body, body)
+        headers_extracted_from_options.each { |name, value| response[name] = value }
       end
 
       response.instance_variable_set(:@read, true)
@@ -31,21 +38,20 @@ module FakeWeb
 
     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 ''
+    def headers_extracted_from_options
+      options.reject {|name, _| KNOWN_OPTIONS.include?(name) }.map { |name, value|
+        [name.to_s.split("_").map { |segment| segment.capitalize }.join("-"), value]
+      }
     end
 
-    def file_response(path)
-      IO.read(path)
-    end
+    def body
+      return '' unless options.has_key?(:body)
 
-    def string_response(string)
-      string
+      if !options[:body].include?("\0") && File.exists?(options[:body]) && !File.directory?(options[:body])
+        File.read(options[:body])
+      else
+        options[:body]
+      end
     end
 
     def baked_response
@@ -95,5 +101,13 @@ module FakeWeb
       options.has_key?(:status) ? options[:status] : [200, 'OK']
     end
 
+    def print_file_string_options_deprecation_warning
+      which = options.has_key?(:file) ? :file : :string
+      $stderr.puts
+      $stderr.puts "Deprecation warning: FakeWeb's :#{which} option has been renamed to :body."
+      $stderr.puts "Just replace :#{which} with :body in your FakeWeb.register_uri calls."
+      $stderr.puts "Called at #{caller[6]}"
+    end
+
   end
 end

data/test/test_allow_net_connect.rb

@@ -20,10 +20,55 @@ class TestFakeWebAllowNetConnect < Test::Unit::TestCase
   def test_raises_for_unregistered_requests_when_allow_net_connect_is_false
     FakeWeb.allow_net_connect = false
     exception = assert_raise FakeWeb::NetConnectNotAllowedError do
-      Net::HTTP.get(URI.parse('http://example.com/'))
+      Net::HTTP.get(URI.parse("http://example.com/"))
     end
   end
 
+  def test_exception_message_includes_unregistered_request_method_and_uri_but_no_default_port
+    FakeWeb.allow_net_connect = false
+    exception = assert_raise FakeWeb::NetConnectNotAllowedError do
+      Net::HTTP.get(URI.parse("http://example.com/"))
+    end
+    assert exception.message.include?("GET http://example.com/")
+
+    exception = assert_raise FakeWeb::NetConnectNotAllowedError do
+      http = Net::HTTP.new("example.com", 443)
+      http.use_ssl = true
+      http.get("/")
+    end
+    assert exception.message.include?("GET https://example.com/")
+  end
+
+  def test_exception_message_includes_unregistered_request_port_when_not_default
+    FakeWeb.allow_net_connect = false
+    exception = assert_raise FakeWeb::NetConnectNotAllowedError do
+      Net::HTTP.start("example.com", 8000) { |http| http.get("/") }
+    end
+    assert exception.message.include?("GET http://example.com:8000/")
+
+    exception = assert_raise FakeWeb::NetConnectNotAllowedError do
+      http = Net::HTTP.new("example.com", 4433)
+      http.use_ssl = true
+      http.get("/")
+    end
+    assert exception.message.include?("GET https://example.com:4433/")
+  end
+
+  def test_exception_message_includes_unregistered_request_port_when_not_default_with_path
+    FakeWeb.allow_net_connect = false
+    exception = assert_raise FakeWeb::NetConnectNotAllowedError do
+      Net::HTTP.start("example.com", 8000) { |http| http.get("/test") }
+    end
+    assert exception.message.include?("GET http://example.com:8000/test")
+
+    exception = assert_raise FakeWeb::NetConnectNotAllowedError do
+      http = Net::HTTP.new("example.com", 4433)
+      http.use_ssl = true
+      http.get("/test")
+    end
+    assert exception.message.include?("GET https://example.com:4433/test")
+  end
+
   def test_question_mark_method_returns_true_after_setting_allow_net_connect_to_true
     FakeWeb.allow_net_connect = true
     assert FakeWeb.allow_net_connect?