webmock 1.2.2 → 1.3.0

data/CHANGELOG.md

@@ -1,5 +1,60 @@
 #Changelog
 
+## 1.3.0
+
+* Added support for [em-http-request](http://github.com/igrigorik/em-http-request)
+
+* Matching query params using a hash	 
+
+	 	 stub_http_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]})
+	 
+	 	 RestClient.get("http://www.example.com/?a[]=b&a[]=c") # ===> Success
+	 	 
+	 	 request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]}).should have_been_made  # ===> Success
+
+* Matching request body against a hash. Body can be URL-Encoded, JSON or XML.
+  (Thanks to Steve Tooke for the idea and a solution for url-encoded bodies)
+
+		stub_http_request(:post, "www.example.com").
+			with(:body => {:data => {:a => '1', :b => 'five'}})
+
+		RestClient.post('www.example.com', "data[a]=1&data[b]=five", 
+	  	:content_type => 'application/x-www-form-urlencoded')    # ===> Success
+	
+		RestClient.post('www.example.com', '{"data":{"a":"1","b":"five"}}', 
+	  	:content_type => 'application/json')    # ===> Success
+	
+		RestClient.post('www.example.com', '<data a="1" b="five" />', 
+			:content_type => 'application/xml' )    # ===> Success
+			
+		request(:post, "www.example.com").
+    	with(:body => {:data => {:a => '1', :b => 'five'}},
+    	 :headers => 'Content-Type' => 'application/json').should have_been_made	 # ===> Success
+
+* Request callbacks (Thanks to Myron Marston for all suggestions)
+
+    WebMock can now invoke callbacks for stubbed or real requests:
+
+		WebMock.after_request do |request_signature, response|
+		  puts "Request #{request_signature} was made and #{response} was returned"
+		end
+    
+    invoke callbacks for real requests only and except requests made with Patron client
+
+		WebMock.after_request(:except => [:patron], :real_requests_only => true)  do |request_signature, response|
+		  puts "Request #{request_signature} was made and #{response} was returned"
+		end
+
+* `to_raise()` now accepts an exception instance or a string as argument in addition to an exception class
+
+		stub_request(:any, 'www.example.net').to_raise(StandardError.new("some error"))
+    
+		stub_request(:any, 'www.example.net').to_raise("some error")
+
+* Matching request stubs based on a URI is 30% faster
+
+* Fixed constant namespace issues in HTTPClient adapter. Thanks to Nathaniel Bibler for submitting a patch.
+
 ## 1.2.2
 
 * Fixed problem where ArgumentError was raised if query params were made up of an array e.g. data[]=a&data[]=b. Thanks to Steve Tooke

data/README.md

@@ -13,10 +13,14 @@ Features
 * Smart matching of the same headers in different representations.
 * Support for Test::Unit
 * Support for RSpec 1.x and RSpec 2.x
-* Support for Net::HTTP and other http libraries based on Net::HTTP (i.e RightHttpConnection, rest-client, HTTParty)
-* Support for HTTPClient library (both sync and async requests)
-* Support for Patron library
-* Easy to extend to other HTTP libraries
+
+Supported HTTP libraries
+------------------------
+
+* Net::HTTP and libraries based on Net::HTTP (i.e RightHttpConnection, REST Client, HTTParty)
+* HTTPClient
+* Patron
+* EM-HTTP-Request
 
 Installation
 ------------
@@ -80,6 +84,20 @@ You can also use WebMock without RSpec or Test::Unit support:
     res = Net::HTTP.start(uri.host, uri.port) {|http|
       http.request(req, 'hello world')
     }    # ===> Success
+    
+### Matching request body against a hash. Body can be URL-Encoded, JSON or XML.
+
+	stub_http_request(:post, "www.example.com").
+		with(:body => {:data => {:a => '1', :b => 'five'}})
+
+	RestClient.post('www.example.com', "data[a]=1&data[b]=five", 
+	  :content_type => 'application/x-www-form-urlencoded')    # ===> Success
+	
+	RestClient.post('www.example.com', '{"data":{"a":"1","b":"five"}}', 
+	  :content_type => 'application/json')    # ===> Success
+	
+	RestClient.post('www.example.com', '<data a="1" b="five" />', 
+	  :content_type => 'application/xml' )    # ===> Success
 
 ### Matching custom request headers
 
@@ -121,7 +139,13 @@ You can also use WebMock without RSpec or Test::Unit support:
 	 stub_request(:any, /.*example.*/)
 
 	 Net::HTTP.get('www.example.com', '/') # ===> Success	
+	 
+### Matching query params using hash	 
 
+	 stub_http_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]})
+	 
+	 RestClient.get("http://www.example.com/?a[]=b&a[]=c") # ===> Success	
+	 
 ### Stubbing with custom response
 
 	stub_request(:any, "www.example.com").to_return(:body => "abc", :status => 200,  :headers => { 'Content-Length' => 3 } )
@@ -179,9 +203,19 @@ You can also use WebMock without RSpec or Test::Unit support:
 
 ### Raising errors
 
+#### Exception declared by class
+
 	stub_request(:any, 'www.example.net').to_raise(StandardError)
 
     RestClient.post('www.example.net', 'abc')    # ===> StandardError
+    
+#### or by exception instance
+
+    stub_request(:any, 'www.example.net').to_raise(StandardError.new("some error"))
+
+#### or by string
+    
+    stub_request(:any, 'www.example.net').to_raise("some error")
 
 ### Raising timeout errors
 
@@ -282,6 +316,11 @@ You can also use WebMock without RSpec or Test::Unit support:
 	WebMock.should_not have_requested(:get, "www.something.com")
 	
 	WebMock.should have_requested(:post, "www.example.com").with { |req| req.body == "abc" }
+	
+	WebMock.should have_requested(:get, "www.example.com").with(:query => {"a" => ["b", "c"]}) 
+
+	WebMock.should have_requested(:get, "www.example.com").
+	  with(:body => {"a" => ["b", "c"]}, :headers => 'Content-Type' => 'application/json')
 
 ### Different way of setting expectations in RSpec
 
@@ -293,6 +332,11 @@ You can also use WebMock without RSpec or Test::Unit support:
 
 	request(:post, "www.example.com").with { |req| req.body == "abc" }.should have_been_made
 	
+	request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]}).should have_been_made
+	
+	request(:post, "www.example.com").
+	  with(:body => {"a" => ["b", "c"]}, :headers => 'Content-Type' => 'application/json').should have_been_made
+	
 ## Clearing stubs and request history
 
 If you want to reset all current stubs and history of requests use `WebMock.reset_webmock`
@@ -402,6 +446,20 @@ i.e the following two sets of headers are equal:
 
 To record your application's real HTTP interactions and replay them later in tests you can use [VCR](http://github.com/myronmarston/vcr) with WebMock.
 
+## Request callbacks
+
+####WebMock can invoke callbacks stubbed or real requests:
+
+    WebMock.after_request do |request_signature, response|
+      puts "Request #{request_signature} was made and #{response} was returned"
+    end
+
+#### invoke callbacks for real requests only and except requests made with Patron
+
+    WebMock.after_request(:except => [:patron], :real_requests_only => true)  do |request_signature, response|
+      puts "Request #{request_signature} was made and #{response} was returned"
+    end
+
 ## Bugs and Issues
 
 Please submit them here [http://github.com/bblimke/webmock/issues](http://github.com/bblimke/webmock/issues)
@@ -439,6 +497,7 @@ People who submitted patches and new features or suggested improvements. Many th
 * Jose Angel Cortinas
 * Razic
 * Steve Tooke
+* Nathaniel Bibler
 
 ## Background
 

data/Rakefile

@@ -11,9 +11,11 @@ begin
     gem.homepage = "http://github.com/bblimke/webmock"
     gem.authors = ["Bartosz Blimke"]
     gem.add_dependency "addressable", ">= 2.1.1"
+    gem.add_dependency "crack", ">=0.1.7"
     gem.add_development_dependency "rspec", ">= 1.2.9"
     gem.add_development_dependency "httpclient", ">= 2.1.5.2"
     gem.add_development_dependency "patron", ">= 0.4.5" unless RUBY_PLATFORM =~ /java/
+    gem.add_development_dependency "em-http-request", ">= 0.2.7" unless RUBY_PLATFORM =~ /java/
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-1.2.2
+1.3.0

data/lib/webmock.rb

@@ -1,10 +1,12 @@
 require 'singleton'
 
 require 'addressable/uri'
+require 'crack'
 
 require 'webmock/http_lib_adapters/net_http'
 require 'webmock/http_lib_adapters/httpclient'
 require 'webmock/http_lib_adapters/patron'
+require 'webmock/http_lib_adapters/em_http_request'
 
 require 'webmock/errors'
 
@@ -20,5 +22,6 @@ require 'webmock/response'
 
 require 'webmock/request_execution_verifier'
 require 'webmock/config'
+require 'webmock/callback_registry'
 require 'webmock/request_registry'
 require 'webmock/webmock'

data/lib/webmock/callback_registry.rb

@@ -0,0 +1,35 @@
+module WebMock
+  class CallbackRegistry
+    @@callbacks = []
+
+    def self.add_callback(options, block)
+      @@callbacks << {:options => options, :block => block}
+    end
+
+    def self.callbacks
+      @@callbacks
+    end
+
+    def self.invoke_callbacks(options, request_signature, response)
+      return if @@callbacks.empty?
+      CallbackRegistry.callbacks.each do |callback|
+        except = callback[:options][:except]
+        real_only = callback[:options][:real_requests_only]
+        unless except && except.include?(options[:lib])
+          if !real_only || options[:real_request]
+            callback[:block].call(request_signature, response)
+          end
+        end
+      end
+    end
+
+    def self.reset
+      @@callbacks = []
+    end
+    
+    def self.any_callbacks?
+      !@@callbacks.empty?
+    end
+
+  end
+end

data/lib/webmock/http_lib_adapters/em_http_request.rb

@@ -0,0 +1,114 @@
+if defined?(EventMachine::HttpRequest)
+
+  module EventMachine
+    class HttpRequest
+
+      class WebMockFakeHttpClient < EventMachine::HttpClient
+
+        def setup(response, uri, error = nil)
+          @uri = uri
+          if error
+            on_error(error)
+            fail(self)
+          else
+            receive_data(response)
+            succeed(self)
+          end
+        end
+        
+        def stream(&blk)
+          blk.call(@response)
+        end
+
+        def unbind
+        end
+
+      end
+
+      def send_request_with_webmock(&block)
+        request_signature = build_request_signature
+
+        WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+        if WebMock.registered_request?(request_signature)
+          webmock_response = WebMock.response_for_request(request_signature)
+          WebMock::CallbackRegistry.invoke_callbacks(
+            {:lib => :em_http_request}, request_signature, webmock_response)
+          client = WebMockFakeHttpClient.new(nil)
+          client.on_error("WebMock timeout error") if webmock_response.should_timeout
+          client.setup(make_raw_response(webmock_response), @uri,
+            webmock_response.should_timeout ? "WebMock timeout error" : nil)
+          client
+        elsif WebMock.net_connect_allowed?(request_signature.uri)
+          http = send_request_without_webmock(&block)
+          http.callback {
+            if WebMock::CallbackRegistry.any_callbacks?
+              webmock_response = build_webmock_response(http)
+              WebMock::CallbackRegistry.invoke_callbacks(
+                {:lib => :em_http_request, :real_request => true}, request_signature,
+                webmock_response)
+            end
+          }
+          http
+        else
+          raise WebMock::NetConnectNotAllowedError.new(request_signature)
+        end
+      end
+      
+      alias_method :send_request_without_webmock, :send_request
+      alias_method :send_request, :send_request_with_webmock
+      
+
+      private
+      
+      def build_webmock_response(http)
+        webmock_response = WebMock::Response.new
+        webmock_response.status = [http.response_header.status, http.response_header.http_reason]
+        webmock_response.headers = http.response_header
+        webmock_response.body = http.response
+        webmock_response
+      end
+
+      def build_request_signature
+        
+        if @options[:authorization] || @options['authorization']
+          auth = (@options[:authorization] || @options['authorization'])
+          userinfo = auth.join(':')
+          userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)
+          @options.reject! {|k,v| k.to_s == 'authorization' } #we added it to url userinfo
+          @uri.userinfo = userinfo
+        end
+        
+       @uri.query_values = (@uri.query_values || {}).merge(@options[:query]) if @options[:query]
+        
+        WebMock::RequestSignature.new(
+          @method.downcase.to_sym,
+          @uri.to_s,
+          :body => (@options[:body] || @options['body']),
+          :headers => (@options[:head] || @options['head'])
+        )
+      end
+
+
+      def make_raw_response(response)            
+        response.raise_error_if_any
+        
+        status, headers, body = response.status, response.headers, response.body
+        
+        response_string = []
+        response_string << "HTTP/1.1 #{status[0]} #{status[1]}"
+
+        headers.each do |header, value|
+          value = value.join(", ") if value.is_a?(Array)
+          response_string << "#{header}: #{value}"
+        end if headers
+
+        response_string << "" << body
+        response_string.join("\n")
+      end
+
+
+    end
+  end
+
+end

data/lib/webmock/http_lib_adapters/httpclient.rb

@@ -1,6 +1,6 @@
-if defined?(HTTPClient)
+if defined?(::HTTPClient)
 
-  class HTTPClient
+  class ::HTTPClient
 
     def do_get_block_with_webmock(req, proxy, conn, &block)
       do_get_with_webmock(req, proxy, conn, false, &block)
@@ -18,15 +18,27 @@ if defined?(HTTPClient)
       if WebMock.registered_request?(request_signature)
         webmock_response = WebMock.response_for_request(request_signature)
         response = build_httpclient_response(webmock_response, stream, &block)
-        conn.push(response)
+        res = conn.push(response)
+        WebMock::CallbackRegistry.invoke_callbacks(
+          {:lib => :http_client}, request_signature, webmock_response) 
+        res
       elsif WebMock.net_connect_allowed?(request_signature.uri)
-        if stream
+        res = if stream
           do_get_stream_without_webmock(req, proxy, conn, &block)
         else
           do_get_block_without_webmock(req, proxy, conn, &block)
         end
+        res = conn.pop
+        conn.push(res)
+        if WebMock::CallbackRegistry.any_callbacks?
+          webmock_response = build_webmock_response(res)
+          WebMock::CallbackRegistry.invoke_callbacks(
+            {:lib => :http_client, :real_request => true}, request_signature,
+            webmock_response)
+        end
+        res
       else
-        raise NetConnectNotAllowedError.new(request_signature)
+        raise WebMock::NetConnectNotAllowedError.new(request_signature)
       end
     end
 
@@ -37,7 +49,7 @@ if defined?(HTTPClient)
       if WebMock.registered_request?(request_signature) || WebMock.net_connect_allowed?(request_signature.uri)
         do_request_async_without_webmock(method, uri, query, body, extheader)
       else
-        raise NetConnectNotAllowedError.new(request_signature)
+        raise WebMock::NetConnectNotAllowedError.new(request_signature)
       end
     end
 
@@ -65,9 +77,24 @@ if defined?(HTTPClient)
       response
     end
   end
+  
+  def build_webmock_response(httpclient_response)
+    webmock_response = WebMock::Response.new
+    webmock_response.status = [httpclient_response.status, httpclient_response.reason]
+    webmock_response.headers = httpclient_response.header.all
+    if  httpclient_response.content.respond_to?(:read)
+      webmock_response.body = httpclient_response.content.read
+      body = HTTP::Message::Body.new
+      body.init_response(StringIO.new(webmock_response.body))
+      httpclient_response.body = body
+    else
+      webmock_response.body = httpclient_response.content
+    end
+    webmock_response
+  end
 
   def build_request_signature(req)
-    uri = Addressable::URI.heuristic_parse(req.header.request_uri.to_s)
+    uri = WebMock::Util::URI.heuristic_parse(req.header.request_uri.to_s)
     uri.query_values = req.header.request_query if req.header.request_query
     uri.port = req.header.request_uri.port
     uri = uri.omit(:userinfo)

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -1,6 +1,7 @@
 require 'net/http'
 require 'net/https'
 require 'stringio'
+require File.join(File.dirname(__FILE__), 'net_http_response')
 
 class StubSocket #:nodoc:
 
@@ -60,10 +61,20 @@ module Net  #:nodoc: all
       if WebMock.registered_request?(request_signature)
         @socket = Net::HTTP.socket_type.new
         webmock_response = WebMock.response_for_request(request_signature)
+        WebMock::CallbackRegistry.invoke_callbacks(
+          {:lib => :net_http}, request_signature, webmock_response)
         build_net_http_response(webmock_response, &block)
       elsif WebMock.net_connect_allowed?(request_signature.uri)
         connect_without_webmock
-        request_without_webmock(request, nil, &block)
+        response = request_without_webmock(request, nil)
+        if WebMock::CallbackRegistry.any_callbacks? && started?
+          webmock_response = build_webmock_response(response)
+          WebMock::CallbackRegistry.invoke_callbacks(
+            {:lib => :net_http, :real_request => true}, request_signature, webmock_response)
+          response.extend WebMock::Net::HTTPResponse   
+        end
+        yield response if block_given?
+        response
       else
         raise WebMock::NetConnectNotAllowedError.new(request_signature)
       end
@@ -99,11 +110,22 @@ module Net  #:nodoc: all
 
       response
     end
+    
+    def build_webmock_response(net_http_response)
+      webmock_response = WebMock::Response.new
+      webmock_response.status = [
+         net_http_response.code.to_i,
+         net_http_response.message]
+      webmock_response.headers = net_http_response.to_hash
+      webmock_response.body = net_http_response.body   
+      webmock_response
+    end
 
   end
 
 end
 
+
 module WebMock
   module NetHTTPUtility
 
@@ -111,7 +133,7 @@ module WebMock
       protocol = net_http.use_ssl? ? "https" : "http"
 
       path = request.path
-      path = Addressable::URI.heuristic_parse(request.path).request_uri if request.path =~ /^http/
+      path = WebMock::Util::URI.heuristic_parse(request.path).request_uri if request.path =~ /^http/
 
       if request["authorization"] =~ /^Basic /
         userinfo = WebMock::Util::Headers.decode_userinfo_from_header(request["authorization"])