webmock 1.2.2 → 1.3.0

data/spec/em_http_request_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'webmock_spec'
+require 'ostruct'
+
+unless RUBY_PLATFORM =~ /java/
+  require 'em_http_request_spec_helper'
+
+  describe "Webmock with EM::HttpRequest" do
+    include EMHttpRequestSpecHelper
+
+    it_should_behave_like "WebMock"
+
+    it "should work with streaming" do
+      stub_http_request(:get, "www.example.com").to_return(:body => "abc")
+      response = ""
+      EM.run {
+        http = EventMachine::HttpRequest.new('http://www.example.com/').get
+        http.stream { |chunk| response = chunk; EM.stop  }
+      }
+      response.should == "abc"
+    end
+
+    it "should work with optional query params" do
+      stub_http_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(:body => "abc")
+      http_request(:get, "http://www.example.com/?x=3", :query => {"a" => ["b", "c"]}).body.should == "abc"
+    end
+
+  end
+end

data/spec/em_http_request_spec_helper.rb

@@ -0,0 +1,64 @@
+module EMHttpRequestSpecHelper
+
+  def failed
+    EventMachine.stop
+    fail
+  end
+
+  def http_request(method, uri, options = {}, &block)
+    response = nil
+    error = nil
+    uri = Addressable::URI.heuristic_parse(uri)
+    EventMachine.run {
+      request = EventMachine::HttpRequest.new("#{uri.omit(:userinfo).normalize.to_s}")
+      http = request.send(:setup_request, method, {
+        :timeout => 2, 
+        :body => options[:body],
+        :query => options[:query],
+        'authorization' => [uri.user, uri.password],
+        :head => options[:headers]}, &block)
+      http.errback {
+        error = http.errors         
+        failed 
+      }
+      headers = {}
+      if http.response_header
+        http.response_header.each do |k,v|
+          v = v.join(", ") if v.is_a?(Array)
+          headers[k] = v 
+        end
+      end
+      http.callback {
+        response = OpenStruct.new({
+          :body => http.response,
+          :headers => WebMock::Util::Headers.normalize_headers(headers),          
+          :message => http.response_header.http_reason,
+          :status => http.response_header.status.to_s
+        })
+        EventMachine.stop
+      }
+    }
+    raise error if error
+    response
+  end
+
+  def client_timeout_exception_class
+    "WebMock timeout error"
+  end
+
+  def connection_refused_exception_class
+    ""
+  end
+
+  def default_client_request_headers(request_method = nil, has_body = false)
+    nil
+  end
+
+  def setup_expectations_for_real_request(options = {})
+  end
+
+  def http_library
+    :em_http_request
+  end
+
+end

data/spec/httpclient_spec_helper.rb

@@ -75,5 +75,9 @@ module HTTPClientSpecHelper
 
     socket.should_receive(:readpartial).any_number_of_times.and_raise(EOFError)
   end
+  
+  def http_library
+    :http_client
+  end
 
 end

data/spec/net_http_spec.rb

@@ -49,9 +49,54 @@ describe "Webmock with Net:HTTP" do
   it "should handle real requests with readable body" do
     WebMock.allow_net_connect!
     req = Net::HTTP::Post.new("/")
-    Net::HTTP.start("www.example.com") {|http| 
+    Net::HTTP.start("www.example.com") {|http|
       http.request(req, StringIO.new("my_params"))
     }.body.should =~ /Example Web Page/
   end
 
+  describe 'after_request callback support' do
+    let(:expected_body_regex) { /You have reached this web page by typing.*example\.com/ }
+
+    before(:each) do
+      WebMock.allow_net_connect!
+      @callback_invocation_count = 0
+      WebMock.after_request do |_, response|
+        @callback_invocation_count += 1
+        @callback_response = response
+      end
+    end
+
+    after(:each) do
+      WebMock.reset_callbacks
+    end
+
+    def perform_get_with_returning_block
+      http_request(:get, "http://www.example.com/") do |response|
+        return response.body
+      end
+    end
+
+    it "should support the after_request callback on an request with block and read_body" do
+      response_body = ''
+      http_request(:get, "http://www.example.com/") do |response|
+        response.read_body { |fragment| response_body << fragment }
+      end
+      response_body.should =~ expected_body_regex
+
+      @callback_response.body.should == response_body
+    end
+
+    it "should support the after_request callback on a request with a returning block" do
+      response_body = perform_get_with_returning_block
+      response_body.should =~ expected_body_regex
+      @callback_response.should be_instance_of(WebMock::Response)
+      @callback_response.body.should == response_body
+    end
+
+    it "should only invoke the after_request callback once, even for a recursive post request" do
+      Net::HTTP.new('example.com', 80).post('/', nil)
+      @callback_invocation_count.should == 1
+    end
+  end
+
 end

data/spec/net_http_spec_helper.rb

@@ -79,4 +79,8 @@ module NetHTTPSpecHelper
     socket.should_receive(read_method).once.and_return("HTTP/1.1 #{options[:response_code]} #{options[:response_message]}\nContent-Length: #{options[:response_body].length}\n\n#{options[:response_body]}")
     socket.should_receive(read_method).any_number_of_times.and_raise(EOFError)
   end
+  
+  def http_library
+    :net_http
+  end
 end

data/spec/other_net_http_libs_spec.rb

@@ -5,6 +5,7 @@ describe "loading other Net::HTTP based libraries" do
   def capture_output_from_requiring(libs, additional_code = "")
     requires = libs.map { |lib| "require '#{lib}'" }
     requires << " require 'addressable/uri'"
+    requires << " require 'crack'"
     requires = requires.join("; ")
     webmock_dir = "#{File.dirname(__FILE__)}/../lib"
     vendor_dirs = Dir["#{File.dirname(__FILE__)}/vendor/*/lib"]

data/spec/patron_spec_helper.rb

@@ -47,4 +47,8 @@ module PatronSpecHelper
     #TODO
   end
 
+  def http_library
+    :patron
+  end
+
 end

data/spec/request_pattern_spec.rb

@@ -5,13 +5,18 @@ describe RequestPattern do
   it "should report string describing itself" do
     RequestPattern.new(:get, "www.example.com",
       :body => "abc", :headers => {'A' => 'a', 'B' => 'b'}).to_s.should ==
-    "GET http://www.example.com/ with body 'abc' with headers {'A'=>'a', 'B'=>'b'}"
+    "GET http://www.example.com/ with body \"abc\" with headers {'A'=>'a', 'B'=>'b'}"
   end
 
   it "should report string describing itself with block" do
     RequestPattern.new(:get, "www.example.com",
       :body => "abc", :headers => {'A' => 'a', 'B' => 'b'}).with {|req| true}.to_s.should ==
-    "GET http://www.example.com/ with body 'abc' with headers {'A'=>'a', 'B'=>'b'} with given block"
+    "GET http://www.example.com/ with body \"abc\" with headers {'A'=>'a', 'B'=>'b'} with given block"
+  end
+  
+  it "should report string describing itself with query params" do
+    RequestPattern.new(:get, /.*example.*/, :query => {'a' => ['b', 'c']}).to_s.should ==
+    "GET /.*example.*/ with query params {\"a\"=>[\"b\", \"c\"]}"
   end
 
   describe "with" do
@@ -119,48 +124,154 @@ describe RequestPattern do
 
     end
 
+    describe "when matching requests on query params" do
 
+      it "should match request query params even if uri is declared as regexp" do
+        RequestPattern.new(:get, /.*example.*/, :query => {"a" => ["b", "c"]}).
+          should match(RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
+      end
 
-    it "should match if request body and body pattern are the same" do
-      RequestPattern.new(:get, "www.example.com", :body => "abc").
-        should match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
-    end
+      it "should match request query params if uri is declared as regexp but params don't match" do
+        RequestPattern.new(:get, /.*example.*/, :query => {"x" => ["b", "c"]}).
+          should_not match(RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
+      end
 
-    it "should match if request body matches regexp" do
-      RequestPattern.new(:get, "www.example.com", :body => /^abc$/).
-        should match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
-    end
+      it "should match for query params are the same as declared in hash" do
+        RequestPattern.new(:get, "www.example.com", :query => {"a" => ["b", "c"]}).
+          should match(RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
+      end
+      
+      it "should not match for query params are different than the declared in hash" do
+        RequestPattern.new(:get, "www.example.com", :query => {"a" => ["b", "c"]}).
+          should_not match(RequestSignature.new(:get, "www.example.com?x[]=b&a[]=c"))
+      end
 
-    it "should not match if body pattern is different than request body" do
-      RequestPattern.new(:get, "www.example.com", :body => "def").
-        should_not match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
-    end
+      it "should match for query params are the same as declared as string" do
+        RequestPattern.new(:get, "www.example.com", :query => "a[]=b&a[]=c").
+          should match(RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
+      end
 
-    it "should not match if request body doesn't match regexp pattern" do
-      RequestPattern.new(:get, "www.example.com", :body => /^abc$/).
-        should_not match(RequestSignature.new(:get, "www.example.com", :body => "xabc"))
-    end
+      it "should match for query params are the same as declared both in query option or url" do
+        RequestPattern.new(:get, "www.example.com/?x=3", :query => "a[]=b&a[]=c").
+          should match(RequestSignature.new(:get, "www.example.com/?x=3&a[]=b&a[]=c"))
+      end
 
-    it "should match if pattern doesn't have specified body" do
-      RequestPattern.new(:get, "www.example.com").
-        should match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
     end
 
-    it "should not match if pattern has body specified as nil but request body is not empty" do
-      RequestPattern.new(:get, "www.example.com", :body => nil).
-        should_not match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
-    end
+    describe "when matching requests with body" do
 
-    it "should not match if pattern has empty body but request body is not empty" do
-      RequestPattern.new(:get, "www.example.com", :body => "").
-        should_not match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
-    end
+      it "should match if request body and body pattern are the same" do
+        RequestPattern.new(:get, "www.example.com", :body => "abc").
+          should match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
+      end
 
-    it "should not match if pattern has body specified but request has no body" do
-      RequestPattern.new(:get, "www.example.com", :body => "abc").
-        should_not match(RequestSignature.new(:get, "www.example.com"))
+      it "should match if request body matches regexp" do
+        RequestPattern.new(:get, "www.example.com", :body => /^abc$/).
+          should match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
+      end
+
+      it "should not match if body pattern is different than request body" do
+        RequestPattern.new(:get, "www.example.com", :body => "def").
+          should_not match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
+      end
+
+      it "should not match if request body doesn't match regexp pattern" do
+        RequestPattern.new(:get, "www.example.com", :body => /^abc$/).
+          should_not match(RequestSignature.new(:get, "www.example.com", :body => "xabc"))
+      end
+
+      it "should match if pattern doesn't have specified body" do
+        RequestPattern.new(:get, "www.example.com").
+          should match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
+      end
+
+      it "should not match if pattern has body specified as nil but request body is not empty" do
+        RequestPattern.new(:get, "www.example.com", :body => nil).
+          should_not match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
+      end
+
+      it "should not match if pattern has empty body but request body is not empty" do
+        RequestPattern.new(:get, "www.example.com", :body => "").
+          should_not match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
+      end
+
+      it "should not match if pattern has body specified but request has no body" do
+        RequestPattern.new(:get, "www.example.com", :body => "abc").
+          should_not match(RequestSignature.new(:get, "www.example.com"))
+      end
+
+      describe "when body in pattern is declared as a hash" do
+        let(:body_hash) { {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']}} }
+
+        describe "for request with url encoded body" do
+          it "should match when hash matches body" do
+            RequestPattern.new(:post, 'www.example.com', :body => body_hash).
+              should match(RequestSignature.new(:post, "www.example.com", :body => 'a=1&c[d][]=e&c[d][]=f&b=five'))
+          end
+
+          it "should match when hash matches body in different order of params" do
+            RequestPattern.new(:post, 'www.example.com', :body => body_hash).
+              should match(RequestSignature.new(:post, "www.example.com", :body => 'a=1&c[d][]=e&b=five&c[d][]=f'))
+          end
+
+          it "should not match when hash doesn't match url encoded body" do
+            RequestPattern.new(:post, 'www.example.com', :body => body_hash).
+              should_not match(RequestSignature.new(:post, "www.example.com", :body => 'c[d][]=f&a=1&c[d][]=e'))
+          end
+
+          it "should not match when body is not url encoded" do
+            RequestPattern.new(:post, 'www.example.com', :body => body_hash).
+              should_not match(RequestSignature.new(:post, "www.example.com", :body => 'foo bar'))
+          end
+
+        end
+
+        describe "for request with json body and content type is set to json" do
+          it "should match when hash matches body" do
+            RequestPattern.new(:post, 'www.example.com', :body => body_hash).
+              should match(RequestSignature.new(:post, "www.example.com", :headers => {:content_type => 'application/json'},
+              :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}"))
+          end
+
+          it "should match if hash matches body in different form" do
+            RequestPattern.new(:post, 'www.example.com', :body => body_hash).
+              should match(RequestSignature.new(:post, "www.example.com", :headers => {:content_type => 'application/json'},
+              :body => "{\"a\":\"1\",\"b\":\"five\",\"c\":{\"d\":[\"e\",\"f\"]}}"))
+          end
+
+          it "should not match when body is not json" do
+            RequestPattern.new(:post, 'www.example.com', :body => body_hash).
+              should_not match(RequestSignature.new(:post, "www.example.com",
+              :headers => {:content_type => 'application/json'}, :body => "foo bar"))
+          end
+        end
+
+        describe "for request with xml body and content type is set to xml" do
+          let(:body_hash) { {"opt" => {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']}}} }
+
+          it "should match when hash matches body" do
+            RequestPattern.new(:post, 'www.example.com', :body => body_hash).
+              should match(RequestSignature.new(:post, "www.example.com", :headers => {:content_type => 'application/xml'},
+              :body => "<opt a=\"1\" b=\"five\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n"))
+          end
+
+          it "should match if hash matches body in different form" do
+            RequestPattern.new(:post, 'www.example.com', :body => body_hash).
+              should match(RequestSignature.new(:post, "www.example.com", :headers => {:content_type => 'application/xml'},
+              :body => "<opt b=\"five\" a=\"1\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n"))
+          end
+
+          it "should not match when body is not xml" do
+            RequestPattern.new(:post, 'www.example.com', :body => body_hash).
+              should_not match(RequestSignature.new(:post, "www.example.com",
+              :headers => {:content_type => 'application/xml'}, :body => "foo bar"))
+          end
+        end
+      end
     end
 
+
+
     it "should match if pattern and request have the same headers" do
       RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}).
         should match(RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))

data/spec/response_spec.rb

@@ -58,6 +58,20 @@ describe Response do
         @response.raise_error_if_any
       }.should raise_error(ArgumentError, "Exception from WebMock")
     end
+    
+    it "should raise error if any assigned as instance" do
+      @response = Response.new(:exception => ArgumentError.new("hello world"))
+      lambda {
+        @response.raise_error_if_any
+      }.should raise_error(ArgumentError, "hello world")
+    end
+    
+    it "should raise error if any assigned as string" do
+      @response = Response.new(:exception => "hello world")
+      lambda {
+        @response.raise_error_if_any
+      }.should raise_error("hello world")
+    end
 
     it "should not raise error if no error assigned" do
       @response.raise_error_if_any

data/spec/spec_helper.rb

@@ -1,6 +1,9 @@
 require 'rubygems'
 require 'httpclient'
-require 'patron' unless RUBY_PLATFORM =~ /java/
+unless RUBY_PLATFORM =~ /java/
+  require 'patron' 
+  require 'em-http'
+end
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))

data/spec/webmock_spec.rb

@@ -16,6 +16,7 @@ describe "WebMock version" do
   
 end
 
+
 describe "WebMock", :shared => true do
   before(:each) do
     WebMock.disable_net_connect!
@@ -39,9 +40,10 @@ describe "WebMock", :shared => true do
         setup_expectations_for_real_example_com_request(
          :host => "www.paypal.com",
          :port => 443,
+         :path => "/uk/cgi-bin/webscr",
          :response_body => "hello paypal"
         )
-        http_request(:get, "https://www.paypal.com/").
+        http_request(:get, "https://www.paypal.com/uk/cgi-bin/webscr").
           body.should =~ /.*paypal.*/
       end
 
@@ -116,7 +118,26 @@ describe "WebMock", :shared => true do
         stub_http_request(:get, /.*x=ab c.*/).to_return(:body => "abc")
         http_request(:get, "http://www.example.com/?#{ESCAPED_PARAMS}").body.should == "abc"
       end
+        
+    end
 
+    describe "on query params" do
+      
+      it "should match the request by query params declared as a hash" do
+        stub_http_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]}).to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/?a[]=b&a[]=c").body.should == "abc"
+      end
+      
+      it "should match the request by query declared as a string" do
+        stub_http_request(:get, "www.example.com").with(:query => "a[]=b&a[]=c").to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/?a[]=b&a[]=c").body.should == "abc"
+      end
+      
+      it "should match the request by query params declared both in uri and query option" do
+        stub_http_request(:get, "www.example.com/?x=3").with(:query => {"a" => ["b", "c"]}).to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/?x=3&a[]=b&a[]=c").body.should == "abc"
+      end
+    
     end
 
     describe "on method" do
@@ -180,6 +201,78 @@ describe "WebMock", :shared => true do
         end
 
       end
+      
+      describe "when body is declared as a hash" do        
+        before(:each) do
+          stub_http_request(:post, "www.example.com").
+            with(:body => {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']} })
+        end
+      
+        describe "for request with url encoded body" do
+      
+          it "should match request if hash matches body" do
+            http_request(
+              :post, "http://www.example.com/",
+              :body => 'a=1&c[d][]=e&c[d][]=f&b=five').status.should == "200"
+          end
+        
+          it "should match request if hash matches body in different order of params" do
+            http_request(
+              :post, "http://www.example.com/",
+              :body => 'a=1&c[d][]=e&b=five&c[d][]=f').status.should == "200"
+          end
+        
+          it "should not match if hash doesn't match url encoded body" do
+            lambda {
+              http_request(
+                :post, "http://www.example.com/",
+                :body => 'c[d][]=f&a=1&c[d][]=e').status.should == "200"
+            }.should raise_error(WebMock::NetConnectNotAllowedError, client_specific_request_string(
+            "Real HTTP connections are disabled. Unregistered request: "+
+            "POST http://www.example.com/ with body 'c[d][]=f&a=1&c[d][]=e'"))
+          end
+        
+        end
+        
+        
+        describe "for request with json body and content type is set to json" do
+          
+          it "should match if hash matches body" do
+            http_request(
+              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
+              :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}").status.should == "200"
+          end
+        
+          it "should match if hash matches body in different form" do
+            http_request(
+              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
+              :body => "{\"a\":\"1\",\"b\":\"five\",\"c\":{\"d\":[\"e\",\"f\"]}}").status.should == "200"
+          end
+        
+        end
+        
+        describe "for request with xml body and content type is set to xml" do
+          before(:each) do
+            WebMock.reset_webmock
+            stub_http_request(:post, "www.example.com").
+              with(:body => { "opt" => {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']} }})
+          end
+        
+          it "should match if hash matches body" do
+            http_request(
+              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'}, 
+              :body => "<opt a=\"1\" b=\"five\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n").status.should == "200"
+          end
+        
+          it "should match if hash matches body in different form" do
+            http_request(
+              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'}, 
+              :body => "<opt b=\"five\" a=\"1\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n").status.should == "200"
+          end
+        
+        end
+      
+      end
 
     end
 
@@ -351,6 +444,20 @@ describe "WebMock", :shared => true do
           http_request(:get, "http://www.example.com/")
         }.should raise_error(MyException, "Exception from WebMock")
       end
+      
+      it "should raise exception if declared in a stubbed response as exception instance" do
+        stub_http_request(:get, "www.example.com").to_raise(MyException.new("hello world"))
+        lambda {
+          http_request(:get, "http://www.example.com/")
+        }.should raise_error(MyException, "hello world")
+      end
+      
+      it "should raise exception if declared in a stubbed response as exception instance" do
+        stub_http_request(:get, "www.example.com").to_raise("hello world")
+        lambda {
+          http_request(:get, "http://www.example.com/")
+        }.should raise_error("hello world")
+      end
 
       it "should raise exception if declared in a stubbed response after returning declared response" do
         stub_http_request(:get, "www.example.com").to_return(:body => "abc").then.to_raise(MyException)
@@ -804,6 +911,35 @@ describe "WebMock", :shared => true do
                     request(:get, /.*example.*/).should have_been_made
                   }.should_not raise_error
                 end
+                
+              end
+
+              describe "when matching requests with query params" do
+                before(:each) do
+                  stub_http_request(:any, /.*example.*/)
+                end
+              
+                it "should pass if the request was executed with query params declared in a hash in query option" do
+                  lambda {
+                    http_request(:get, "http://www.example.com/?a[]=b&a[]=c")
+                    request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]}).should have_been_made
+                  }.should_not raise_error
+                end
+
+                it "should pass if the request was executed with query params declared as string in query option" do
+                  lambda {
+                    http_request(:get, "http://www.example.com/?a[]=b&a[]=c")
+                    request(:get, "www.example.com").with(:query => "a[]=b&a[]=c").should have_been_made
+                  }.should_not raise_error
+                end
+
+                it "should pass if the request was executed with query params both in uri and in query option" do
+                  lambda {
+                    http_request(:get, "http://www.example.com/?x=3&a[]=b&a[]=c")
+                    request(:get, "www.example.com/?x=3").with(:query => {"a" => ["b", "c"]}).should have_been_made
+                  }.should_not raise_error
+                end
+              
               end
 
               it "should fail if requested more times than expected" do
@@ -840,22 +976,99 @@ describe "WebMock", :shared => true do
                   http_request(:get, "http://www.example.com/", :body => "abc")
                   request(:get, "www.example.com").
                   with(:body => "def").should have_been_made
-                }.should fail_with("The request GET http://www.example.com/ with body 'def' was expected to execute 1 time but it executed 0 times")
+                }.should fail_with('The request GET http://www.example.com/ with body "def" was expected to execute 1 time but it executed 0 times')
               end
 
-              it "should succeed if request was executed with the same body" do
-                lambda {
-                  http_request(:post, "http://www.example.com/", :body => "abc")
-                  request(:post, "www.example.com").with(:body => /^abc$/).should have_been_made
-                }.should_not raise_error
+              describe "when expected body is declared as regexp" do
+
+                it "should succeed if request was executed with the same body" do
+                  lambda {
+                    http_request(:post, "http://www.example.com/", :body => "abc")
+                    request(:post, "www.example.com").with(:body => /^abc$/).should have_been_made
+                  }.should_not raise_error
+                end
+
+                it "should fail if request was executed with different body" do
+                  lambda {
+                    http_request(:get, "http://www.example.com/", :body => /^abc/)
+                    request(:get, "www.example.com").
+                    with(:body => "xabc").should have_been_made
+                  }.should fail_with('The request GET http://www.example.com/ with body "xabc" was expected to execute 1 time but it executed 0 times')
+                end
+              
               end
+              
+              describe "when expected body is declared as a hash" do
+                let(:body_hash) { {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']}} }
+                let(:fail_message) {'The request POST http://www.example.com/ with body {"a"=>"1", "b"=>"five", "c"=>{"d"=>["e", "f"]}} was expected to execute 1 time but it executed 0 times'}
 
-              it "should fail if request was executed with different body" do
-                lambda {
-                  http_request(:get, "http://www.example.com/", :body => /^abc/)
-                  request(:get, "www.example.com").
-                  with(:body => "xabc").should have_been_made
-                }.should fail_with("The request GET http://www.example.com/ with body 'xabc' was expected to execute 1 time but it executed 0 times")
+                describe "when request is executed with url encoded body matching hash" do
+                
+                  it "should succeed" do
+                    lambda {
+                      http_request(:post, "http://www.example.com/", :body => 'a=1&c[d][]=e&c[d][]=f&b=five')
+                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                    }.should_not raise_error
+                  end
+                  
+                  it "should succeed if url encoded params have different order" do
+                    lambda {
+                      http_request(:post, "http://www.example.com/", :body => 'a=1&c[d][]=e&b=five&c[d][]=f')
+                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                    }.should_not raise_error
+                  end
+
+                  it "should fail if request is executed with url encoded body not matching hash" do
+                    lambda {
+                      http_request(:post, "http://www.example.com/", :body => 'c[d][]=f&a=1&c[d][]=e')
+                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                    }.should fail_with(fail_message)
+                  end
+                
+                end
+
+                describe "when request is executed with json body matching hash and content type is set to json" do
+
+                  it "should succeed" do
+                    lambda {
+                      http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
+                        :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}")
+                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                    }.should_not raise_error
+                  end
+                  
+                  it "should succeed if json body is in different form" do
+                    lambda {
+                      http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
+                        :body => "{\"a\":\"1\",\"b\":\"five\",\"c\":{\"d\":[\"e\",\"f\"]}}")
+                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                    }.should_not raise_error
+                  end
+                
+                end
+
+
+                describe "when request is executed with xml body matching hash and content type is set to xml" do
+                  let(:body_hash) { { "opt" => {:a => "1", :b => 'five', 'c' => {'d' => ['e', 'f']}} }}
+                  
+                  it "should succeed" do
+                    lambda {
+                      http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
+                        :body => "<opt a=\"1\" b=\"five\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n")
+                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                    }.should_not raise_error
+                  end
+                
+                  it "should succeed if xml body is in different form" do
+                    lambda {
+                      http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
+                        :body => "<opt b=\"five\" a=\"1\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n")
+                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                    }.should_not raise_error
+                  end
+              
+                end
+                
               end
 
               it "should succeed if request was executed with the same headers" do
@@ -1137,4 +1350,140 @@ describe "WebMock", :shared => true do
 
           end
 
+
+  describe "callbacks" do
+    
+    describe "after_request" do
+      before(:each) do
+        WebMock.reset_callbacks
+        stub_request(:get, "http://www.example.com")
+      end
+  
+      it "should not invoke callback unless request is made" do
+        WebMock.after_request {
+          @called = true
+        }
+        @called.should == nil
+      end
+  
+      it "should invoke a callback after request is made" do
+        WebMock.after_request {
+          @called = true
+        }
+        http_request(:get, "http://www.example.com/")
+        @called.should == true
+      end
+    
+      it "should not invoke a callback if specific http library should be ignored" do
+        WebMock.after_request(:except => [http_library()]) {
+          @called = true
+        }
+        http_request(:get, "http://www.example.com/")
+        @called.should == nil
+      end
+  
+      it "should invoke a callback even if other http libraries should be ignored" do
+        WebMock.after_request(:except => [:other_lib]) {
+          @called = true
+        }
+        http_request(:get, "http://www.example.com/")
+        @called.should == true
+      end
+  
+      it "should pass request signature to the callback" do
+        WebMock.after_request(:except => [:other_lib])  do |request_signature, _|
+          @request_signature = request_signature
+        end
+        http_request(:get, "http://www.example.com/")
+        @request_signature.uri.to_s.should == "http://www.example.com:80/"
+      end
+      
+      describe "passing response to callback" do
+
+        describe "for stubbed requests" do
+          before(:each) do
+            stub_request(:get, "http://www.example.com").
+              to_return(
+                :status => ["200", "hello"],
+                :headers => {'Content-Length' => '666', 'Hello' => 'World'},
+                :body => "foo bar"
+              )
+            WebMock.after_request(:except => [:other_lib])  do |_, response|
+              @response = response
+            end
+            http_request(:get, "http://www.example.com/")
+          end
+
+          it "should pass response with status and message" do            
+            @response.status.should == ["200", "hello"]
+          end
+        
+          it "should pass response with headers" do
+            @response.headers.should == {
+              'Content-Length' => '666', 
+              'Hello' => 'World'
+            }
+          end
+        
+          it "should pass response with body" do
+            @response.body.should == "foo bar"
+          end
+      
+        end
+        
+        describe "for real requests" do
+          before(:each) do
+            WebMock.reset_webmock
+            WebMock.allow_net_connect!
+            WebMock.after_request(:except => [:other_lib])  do |_, response|
+              @response = response
+            end
+            http_request(:get, "http://www.example.com/")
+          end
+
+          it "should pass response with status and message" do
+            @response.status[0].should == 200
+            @response.status[1].should == "OK"
+          end
+        
+          it "should pass response with headers" do
+            @response.headers["Content-Length"].should == "574"
+          end
+        
+          it "should pass response with body" do
+            @response.body.size.should == 574
+          end
+      
         end
+      
+      end
+  
+      it "should invoke multiple callbacks in order of their declarations" do
+        WebMock.after_request { @called = 1 }
+        WebMock.after_request { @called += 1 }
+        http_request(:get, "http://www.example.com/")
+        @called.should == 2
+      end
+      
+      it "should invoke callbacks only for real requests if requested" do
+        WebMock.after_request(:real_requests_only => true) { @called = true }
+        http_request(:get, "http://www.example.com/")
+        @called.should == nil
+        WebMock.allow_net_connect!
+        http_request(:get, "http://www.example.net/")
+        @called.should == true
+      end
+      
+      it "should clear all declared callbacks on reset callbacks" do
+        WebMock.after_request { @called = 1 }
+        WebMock.reset_callbacks
+        stub_request(:get, "http://www.example.com")        
+        http_request(:get, "http://www.example.com/")
+        @called.should == nil
+      end
+      
+    end
+  
+  end
+
+end