webmock 1.7.5 → 1.7.6

data/spec/acceptance/shared/returning_declared_responses.rb

@@ -0,0 +1,377 @@
+class MyException < StandardError; end;
+
+shared_context "declared responses" do
+  describe "when request stub declares that request should raise exception" do
+    it "should raise exception" do
+      stub_request(:get, "www.example.com").to_raise(MyException)
+      lambda {
+        http_request(:get, "http://www.example.com/")
+      }.should raise_error(MyException, "Exception from WebMock")
+    end
+
+    it "should raise exception if declared as and exception instance" do
+      stub_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 as an exception instance" do
+      stub_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 after returning declared successful response first" do
+      stub_request(:get, "www.example.com").to_return(:body => "abc").then.to_raise(MyException)
+      http_request(:get, "http://www.example.com/").body.should == "abc"
+      lambda {
+        http_request(:get, "http://www.example.com/")
+      }.should raise_error(MyException, "Exception from WebMock")
+    end
+  end
+
+  describe "when request stub declares that request should timeout" do
+    it "should timeout" do
+      stub_request(:get, "www.example.com").to_timeout
+      lambda {
+        http_request(:get, "http://www.example.com/")
+      }.should raise_error(client_timeout_exception_class)
+    end
+
+    it "should timeout after returning declared successful response" do
+      stub_request(:get, "www.example.com").to_return(:body => "abc").then.to_timeout
+      http_request(:get, "http://www.example.com/").body.should == "abc"
+      lambda {
+        http_request(:get, "http://www.example.com/")
+      }.should raise_error(client_timeout_exception_class)
+    end
+  end
+
+  describe "when request stub declares that request should return a response" do
+    it "should return response with declared body" do
+      stub_request(:get, "www.example.com").to_return(:body => "abc")
+      http_request(:get, "http://www.example.com/").body.should == "abc"
+    end
+
+    it "should return response with declared headers" do
+      stub_request(:get, "www.example.com").to_return(:headers => SAMPLE_HEADERS)
+      response = http_request(:get, "http://www.example.com/")
+      response.headers["Content-Length"].should == "8888"
+    end
+
+    it "should return response with declared headers even if there are multiple headers with the same key" do
+      stub_request(:get, "www.example.com").to_return(:headers => {"a" => ["b", "c"]})
+      response = http_request(:get, "http://www.example.com/")
+      response.headers["A"].should == "b, c"
+    end
+
+    it "should return response with declared status code" do
+      stub_request(:get, "www.example.com").to_return(:status => 500)
+      http_request(:get, "http://www.example.com/").status.should == "500"
+    end
+
+    it "should return response with declared status message" do
+      stub_request(:get, "www.example.com").to_return(:status => [500, "Internal Server Error"])
+      response = http_request(:get, "http://www.example.com/")
+      # not supported by em-http-request, it always returns "unknown" for http_reason
+      unless http_library == :em_http_request
+        response.message.should == "Internal Server Error"
+      end
+    end
+
+    it "should return response with a default status code" do
+      stub_request(:get, "www.example.com")
+      http_request(:get, "http://www.example.com/").status.should == "200"
+    end
+
+    it "should return default response with empty message if response was not declared" do
+      stub_request(:get, "www.example.com")
+      response = http_request(:get, "http://www.example.com/")
+      # not supported by em-http-request, it always returns "unknown" for http_reason
+      unless http_library == :em_http_request
+        response.message.should == ""
+      end
+    end
+
+    describe "when response body was declared as IO" do
+      it "should return response body" do
+        stub_request(:get, "www.example.com").to_return(:body => File.new(__FILE__))
+        http_request(:get, "http://www.example.com/").body.should == File.new(__FILE__).read
+      end
+
+      it "should return response body if requested many times" do
+        stub_request(:get, "www.example.com").to_return(:body => File.new(__FILE__))
+        2.times do
+          http_request(:get, "http://www.example.com/").body.should == File.new(__FILE__).read
+        end
+      end
+
+      it "should close IO after request" do
+        stub_request(:get, "www.example.com").to_return(:body => @file = File.new(__FILE__))
+        @file.should be_closed
+      end
+    end
+
+    describe "when response parts were declared as lambdas" do
+      it "should return evaluated response body" do
+        stub_request(:post, "www.example.com").to_return(:body => lambda { |request| request.body })
+        http_request(:post, "http://www.example.com/", :body => "echo").body.should == "echo"
+      end
+
+      it "should return evaluated response headers" do
+        stub_request(:post, "www.example.com").to_return(:headers => lambda { |request| request.headers })
+        http_request(:post, "http://www.example.com/", :body => "abc", :headers => {'A' => 'B'}).headers['A'].should == 'B'
+      end
+    end
+
+    describe "when response was declared as lambda" do
+      class Responder
+        def call(request)
+          {:body => request.body}
+        end
+      end
+
+      it "should return evaluated response body" do
+        stub_request(:post, "www.example.com").to_return(lambda {|request|
+                                                                {:body => request.body}
+        })
+        http_request(:post, "http://www.example.com/", :body => "echo").body.should == "echo"
+      end
+
+      it "should return evaluated response headers" do
+        stub_request(:get, "www.example.com").to_return(lambda { |request|
+                                                               {:headers => request.headers}
+        })
+        http_request(:get, "http://www.example.com/", :headers => {'A' => 'B'}).headers['A'].should == 'B'
+      end
+
+      it "should return dynamic response declared as a block" do
+        stub_request(:post, "www.example.com").to_return do |request|
+          {:body => request.body}
+        end
+        http_request(:post, "http://www.example.com/", :body => "echo").body.should == "echo"
+      end
+
+      it "should return dynamic response declared as an object responding to call" do
+        stub_request(:post, "www.example.com").to_return(Responder.new)
+        http_request(:post, "http://www.example.com/", :body => "echo").body.should == "echo"
+      end
+    end
+
+
+    describe "when response was declared as a file with a raw response" do
+      before(:each) do
+        @file = File.new(CURL_EXAMPLE_OUTPUT_PATH)
+        stub_request(:get, "www.example.com").to_return(@file)
+        @response = http_request(:get, "http://www.example.com/")
+      end
+
+      it "should return recorded headers" do
+        @response.headers.should == {
+          "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
+          "Content-Type"=>"text/html; charset=UTF-8",
+          "Content-Length"=>"419",
+          "Connection"=>"Keep-Alive",
+          "Accept"=>"image/jpeg, image/png"
+        }
+      end
+
+      it "should return recorded body" do
+        @response.body.size.should == 419
+      end
+
+      it "should return recorded status" do
+        @response.status.should == "202"
+      end
+
+      it "should return recorded status message" do
+        # not supported by em-http-request, it always returns "unknown" for http_reason
+        unless http_library == :em_http_request
+          @response.message.should == "OK"
+        end
+      end
+
+      it "should ensure file is closed" do
+        @file.should be_closed
+      end
+    end
+
+    describe "when response was declared as a string with a raw response" do
+      before(:each) do
+        @input = File.new(CURL_EXAMPLE_OUTPUT_PATH).read
+        stub_request(:get, "www.example.com").to_return(@input)
+        @response = http_request(:get, "http://www.example.com/")
+      end
+
+      it "should return recorded headers" do
+        @response.headers.should == {
+          "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
+          "Content-Type"=>"text/html; charset=UTF-8",
+          "Content-Length"=>"419",
+          "Connection"=>"Keep-Alive",
+          "Accept"=>"image/jpeg, image/png"
+        }
+      end
+
+      it "should return recorded body" do
+        @response.body.size.should == 419
+      end
+
+      it "should return recorded status" do
+        @response.status.should == "202"
+      end
+
+      it "should return recorded status message" do
+        # not supported by em-http-request, it always returns "unknown" for http_reason
+        unless http_library == :em_http_request
+          @response.message.should == "OK"
+        end
+      end
+    end
+
+    describe "when response was declared as lambda evaluating to a string with a raw response" do
+      before(:each) do
+        @files = {
+          "www.example.com" => File.new(CURL_EXAMPLE_OUTPUT_PATH)
+        }
+      end
+
+      it "should return response from evaluated file" do
+        stub_request(:get, "www.example.com").to_return(lambda {|request| @files[request.uri.host.to_s] })
+        http_request(:get, "http://www.example.com/").body.size.should == 419
+      end
+
+      it "should return response from evaluated string" do
+        stub_request(:get, "www.example.com").to_return(lambda {|request| @files[request.uri.host.to_s].read })
+        http_request(:get, "http://www.example.com/").body.size.should == 419
+      end
+    end
+
+    describe "when response is declared as an Rack app" do
+      before(:each) do
+        stub_request(:any, "http://www.example.com/greet").to_rack(MyRackApp)
+      end
+
+      it "should return response returned by the rack app" do
+        http_request(:post, 'http://www.example.com/greet', :body => 'name=Jimmy').body.should == 'Good to meet you, Jimmy!'
+      end
+    end
+
+    describe "when sequences of responses are declared" do
+      it "should return responses one by one if declared in array" do
+        stub_request(:get, "www.example.com").to_return([ {:body => "1"}, {:body => "2"}, {:body => "3"} ])
+        http_request(:get, "http://www.example.com/").body.should == "1"
+        http_request(:get, "http://www.example.com/").body.should == "2"
+        http_request(:get, "http://www.example.com/").body.should == "3"
+      end
+
+      it "should repeat returning last declared response from a sequence after all responses were returned" do
+        stub_request(:get, "www.example.com").to_return([ {:body => "1"}, {:body => "2"} ])
+        http_request(:get, "http://www.example.com/").body.should == "1"
+        http_request(:get, "http://www.example.com/").body.should == "2"
+        http_request(:get, "http://www.example.com/").body.should == "2"
+      end
+
+      it "should return responses one by one if declared as comma separated params" do
+        stub_request(:get, "www.example.com").to_return({:body => "1"}, {:body => "2"}, {:body => "3"})
+        http_request(:get, "http://www.example.com/").body.should == "1"
+        http_request(:get, "http://www.example.com/").body.should == "2"
+        http_request(:get, "http://www.example.com/").body.should == "3"
+      end
+
+      it "should return responses one by one if declared with several to_return invokations" do
+        stub_request(:get, "www.example.com").
+          to_return({:body => "1"}).
+          to_return({:body => "2"}).
+          to_return({:body => "3"})
+        http_request(:get, "http://www.example.com/").body.should == "1"
+        http_request(:get, "http://www.example.com/").body.should == "2"
+        http_request(:get, "http://www.example.com/").body.should == "3"
+      end
+
+      it "should return responses one by one if declared with to_return invocations separated with then syntactic sugar" do
+        stub_request(:get, "www.example.com").to_return({:body => "1"}).then.
+          to_return({:body => "2"}).then.to_return({:body => "3"})
+        http_request(:get, "http://www.example.com/").body.should == "1"
+        http_request(:get, "http://www.example.com/").body.should == "2"
+        http_request(:get, "http://www.example.com/").body.should == "3"
+      end
+
+    end
+
+    describe "when responses are declared to return more than once" do
+      it "should repeat one response declared number of times" do
+        stub_request(:get, "www.example.com").
+          to_return({:body => "1"}).times(2).
+          to_return({:body => "2"})
+        http_request(:get, "http://www.example.com/").body.should == "1"
+        http_request(:get, "http://www.example.com/").body.should == "1"
+        http_request(:get, "http://www.example.com/").body.should == "2"
+      end
+
+
+      it "should repeat sequence of response declared number of times" do
+        stub_request(:get, "www.example.com").
+          to_return({:body => "1"}, {:body => "2"}).times(2).
+          to_return({:body => "3"})
+        http_request(:get, "http://www.example.com/").body.should == "1"
+        http_request(:get, "http://www.example.com/").body.should == "2"
+        http_request(:get, "http://www.example.com/").body.should == "1"
+        http_request(:get, "http://www.example.com/").body.should == "2"
+        http_request(:get, "http://www.example.com/").body.should == "3"
+      end
+
+
+      it "should repeat infinitely last response even if number of declared times is lower" do
+        stub_request(:get, "www.example.com").
+          to_return({:body => "1"}).times(2)
+        http_request(:get, "http://www.example.com/").body.should == "1"
+        http_request(:get, "http://www.example.com/").body.should == "1"
+        http_request(:get, "http://www.example.com/").body.should == "1"
+      end
+
+      it "should give error if times is declared without specifying response" do
+        lambda {
+          stub_request(:get, "www.example.com").times(3)
+        }.should raise_error("Invalid WebMock stub declaration. times(N) can be declared only after response declaration.")
+      end
+
+    end
+
+    describe "when exception is declared to be raised more than once" do
+      it "should repeat raising exception declared number of times" do
+        stub_request(:get, "www.example.com").
+          to_raise(MyException).times(2).
+          to_return({:body => "2"})
+        lambda {
+          http_request(:get, "http://www.example.com/")
+        }.should raise_error(MyException, "Exception from WebMock")
+        lambda {
+          http_request(:get, "http://www.example.com/")
+        }.should raise_error(MyException, "Exception from WebMock")
+        http_request(:get, "http://www.example.com/").body.should == "2"
+      end
+
+      it "should repeat raising sequence of exceptions declared number of times" do
+        stub_request(:get, "www.example.com").
+          to_raise(MyException, ArgumentError).times(2).
+          to_return({:body => "2"})
+        lambda {
+          http_request(:get, "http://www.example.com/")
+        }.should raise_error(MyException, "Exception from WebMock")
+        lambda {
+          http_request(:get, "http://www.example.com/")
+        }.should raise_error(ArgumentError)
+        lambda {
+          http_request(:get, "http://www.example.com/")
+        }.should raise_error(MyException, "Exception from WebMock")
+        lambda {
+          http_request(:get, "http://www.example.com/")
+        }.should raise_error(ArgumentError)
+        http_request(:get, "http://www.example.com/").body.should == "2"
+      end
+    end
+  end
+end

data/spec/acceptance/shared/stubbing_requests.rb

@@ -0,0 +1,314 @@
+shared_examples_for "stubbing requests" do
+  describe "when requests are stubbed" do
+    describe "based on uri" do
+      it "should return stubbed response even if request have escaped parameters" do
+        stub_request(:get, "www.example.com/hello/?#{NOT_ESCAPED_PARAMS}").to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/hello/?#{ESCAPED_PARAMS}").body.should == "abc"
+      end
+
+      it "should return stubbed response even if request has non escaped params" do
+        stub_request(:get, "www.example.com/hello/?#{ESCAPED_PARAMS}").to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/hello/?#{NOT_ESCAPED_PARAMS}").body.should == "abc"
+      end
+
+      it "should return stubbed response even if stub uri is declared as regexp and request params are escaped" do
+        stub_request(:get, /.*x=ab c.*/).to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/hello/?#{ESCAPED_PARAMS}").body.should == "abc"
+      end
+    end
+
+    describe "based on query params" do
+      it "should return stubbed response when stub declares query params as a hash" do
+        stub_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 return stubbed response when stub declares query params as a hash" do
+        stub_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 return stubbed response when stub declares query params both in uri and as a hash" do
+        stub_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 "based on method" do
+      it "should return stubbed response" do
+        stub_request(:get, "www.example.com")
+        http_request(:get, "http://www.example.com/").status.should == "200"
+      end
+
+      it "should raise error if stubbed request has different method" do
+        stub_request(:get, "www.example.com")
+        http_request(:get, "http://www.example.com/").status.should == "200"
+        lambda {
+          http_request(:delete, "http://www.example.com/")
+        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: DELETE http://www.example.com/)
+                             )
+      end
+    end
+
+    describe "based on body" do
+      it "should match requests if body is the same" do
+        stub_request(:post, "www.example.com").with(:body => "abc")
+        http_request(
+          :post, "http://www.example.com/",
+        :body => "abc").status.should == "200"
+      end
+
+      it "should match requests if body is not set in the stub" do
+        stub_request(:post, "www.example.com")
+        http_request(
+          :post, "http://www.example.com/",
+        :body => "abc").status.should == "200"
+      end
+
+      it "should not match requests if body is different" do
+        stub_request(:post, "www.example.com").with(:body => "abc")
+        lambda {
+          http_request(:post, "http://www.example.com/", :body => "def")
+        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: POST http://www.example.com/ with body 'def'))
+      end
+
+      describe "with regular expressions" do
+        it "should match requests if body matches regexp" do
+          stub_request(:post, "www.example.com").with(:body => /\d+abc$/)
+          http_request(
+            :post, "http://www.example.com/",
+          :body => "123abc").status.should == "200"
+        end
+
+        it "should not match requests if body doesn't match regexp" do
+          stub_request(:post, "www.example.com").with(:body => /^abc/)
+          lambda {
+            http_request(:post, "http://www.example.com/", :body => "xabc")
+          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: POST http://www.example.com/ with body 'xabc'))
+        end
+      end
+
+      describe "when body is declared as a hash" do
+        before(:each) do
+          stub_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, %r(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
+
+          it "should match if hash contains date string" do #Crack creates date object
+            WebMock.reset!
+            stub_request(:post, "www.example.com").
+              with(:body => {"foo" => "2010-01-01"})
+            http_request(
+              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
+            :body => "{\"foo\":\"2010-01-01\"}").status.should == "200"
+          end
+        end
+
+        describe "for request with xml body and content type is set to xml" do
+          before(:each) do
+            WebMock.reset!
+            stub_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
+
+          it "should match if hash contains date string" do #Crack creates date object
+            WebMock.reset!
+            stub_request(:post, "www.example.com").
+              with(:body => {"opt" => {"foo" => "2010-01-01"}})
+            http_request(
+              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
+            :body => "<opt foo=\"2010-01-01\">\n</opt>\n").status.should == "200"
+          end
+        end
+      end
+    end
+
+    describe "based on headers" do
+      it "should match requests if headers are the same" do
+        stub_request(:get, "www.example.com").with(:headers => SAMPLE_HEADERS )
+        http_request(
+          :get, "http://www.example.com/",
+        :headers => SAMPLE_HEADERS).status.should == "200"
+      end
+
+      it "should match requests if headers are the same and declared as array" do
+        stub_request(:get, "www.example.com").with(:headers => {"a" => ["b"]} )
+        http_request(
+          :get, "http://www.example.com/",
+        :headers => {"a" => "b"}).status.should == "200"
+      end
+
+      describe "when multiple headers with the same key are used" do
+        it "should match requests if headers are the same" do
+          stub_request(:get, "www.example.com").with(:headers => {"a" => ["b", "c"]} )
+          http_request(
+            :get, "http://www.example.com/",
+          :headers => {"a" => ["b", "c"]}).status.should == "200"
+        end
+
+        it "should match requests if headers are the same  but in different order" do
+          stub_request(:get, "www.example.com").with(:headers => {"a" => ["b", "c"]} )
+          http_request(
+            :get, "http://www.example.com/",
+          :headers => {"a" => ["c", "b"]}).status.should == "200"
+        end
+
+        it "should not match requests if headers are different" do
+          stub_request(:get, "www.example.com").with(:headers => {"a" => ["b", "c"]})
+
+          lambda {
+            http_request(
+              :get, "http://www.example.com/",
+            :headers => {"a" => ["b", "d"]})
+          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/ with headers))
+        end
+      end
+
+      it "should match requests if request headers are not stubbed" do
+        stub_request(:get, "www.example.com")
+        http_request(
+          :get, "http://www.example.com/",
+        :headers => SAMPLE_HEADERS).status.should == "200"
+      end
+
+      it "should not match requests if headers are different" do
+        stub_request(:get, "www.example.com").with(:headers => SAMPLE_HEADERS)
+
+        lambda {
+          http_request(
+            :get, "http://www.example.com/",
+          :headers => { 'Content-Length' => '9999'})
+        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/ with headers))
+      end
+
+      it "should not match if accept header is different" do
+        stub_request(:get, "www.example.com").
+          with(:headers => { 'Accept' => 'application/json'})
+        lambda {
+          http_request(
+            :get, "http://www.example.com/",
+          :headers => { 'Accept' => 'application/xml'})
+        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/ with headers))
+      end
+
+      describe "declared as regular expressions" do
+        it "should match requests if header values match regular expression" do
+          stub_request(:get, "www.example.com").with(:headers => { :some_header => /^MyAppName$/ })
+          http_request(
+            :get, "http://www.example.com/",
+          :headers => { 'some-header' => 'MyAppName' }).status.should == "200"
+        end
+
+        it "should not match requests if headers values do not match regular expression" do
+          stub_request(:get, "www.example.com").with(:headers => { :some_header => /^MyAppName$/ })
+
+          lambda {
+            http_request(
+              :get, "http://www.example.com/",
+            :headers => { 'some-header' => 'xMyAppName' })
+          }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/ with headers))
+        end
+      end
+    end
+
+    describe "when stubbing request with basic authentication" do
+      it "should match if credentials are the same" do
+        stub_request(:get, "user:pass@www.example.com")
+        http_request(:get, "http://user:pass@www.example.com/").status.should == "200"
+      end
+
+      it "should not match if credentials are different" do
+        stub_request(:get, "user:pass@www.example.com")
+        lambda {
+          http_request(:get, "http://user:pazz@www.example.com/").status.should == "200"
+        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://user:pazz@www.example.com/))
+      end
+
+      it "should not match if credentials are stubbed but not provided in the request" do
+        stub_request(:get, "user:pass@www.example.com")
+        lambda {
+          http_request(:get, "http://www.example.com/").status.should == "200"
+        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+      end
+
+      it "should not match if credentials are not stubbed but exist in the request" do
+        stub_request(:get, "www.example.com")
+        lambda {
+          http_request(:get, "http://user:pazz@www.example.com/").status.should == "200"
+        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://user:pazz@www.example.com/))
+      end
+    end
+
+    describe "when stubbing request with a block evaluated on request" do
+      it "should match if block returns true" do
+        stub_request(:get, "www.example.com").with { |request| true }
+        http_request(:get, "http://www.example.com/").status.should == "200"
+      end
+
+      it "should not match if block returns false" do
+        stub_request(:get, "www.example.com").with { |request| false }
+        lambda {
+          http_request(:get, "http://www.example.com/")
+        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+      end
+
+      it "should pass the request to the block" do
+        stub_request(:post, "www.example.com").with { |request| request.body == "wadus" }
+        http_request(
+          :post, "http://www.example.com/",
+        :body => "wadus").status.should == "200"
+        lambda {
+          http_request(:post, "http://www.example.com/", :body => "jander")
+        }.should raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: POST http://www.example.com/ with body 'jander'))
+      end
+    end
+  end
+end