webmock 1.20.3 → 1.20.4

data/spec/acceptance/shared/returning_declared_responses.rb

@@ -4,126 +4,126 @@ shared_context "declared responses" do |*adapter_info|
   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 {
+      expect {
         http_request(:get, "http://www.example.com/")
-      }.should raise_error(MyException, "Exception from WebMock")
+      }.to 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 {
+      expect {
         http_request(:get, "http://www.example.com/")
-      }.should raise_error(MyException, "hello world")
+      }.to 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 {
+      expect {
         http_request(:get, "http://www.example.com/")
-      }.should raise_error("hello world")
+      }.to 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 {
+      expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
+      expect {
         http_request(:get, "http://www.example.com/")
-      }.should raise_error(MyException, "Exception from WebMock")
+      }.to 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 {
+      expect {
         http_request(:get, "http://www.example.com/")
-      }.should raise_error(client_timeout_exception_class)
+      }.to 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 {
+      expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
+      expect {
         http_request(:get, "http://www.example.com/")
-      }.should raise_error(client_timeout_exception_class)
+      }.to 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"
+      expect(http_request(:get, "http://www.example.com/").body).to eq("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"
+      expect(response.headers["Content-Length"]).to eq("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"
+      expect(response.headers["A"]).to eq("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"
+      expect(http_request(:get, "http://www.example.com/").status).to eq("500")
     end
 
     it "should return response with declared status message", :unless => (adapter_info.include?(:no_status_message)) do
       stub_request(:get, "www.example.com").to_return(:status => [500, "Internal Server Error"])
       response = http_request(:get, "http://www.example.com/")
-      response.message.should == "Internal Server Error"
+      expect(response.message).to eq("Internal Server Error")
     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"
+      expect(http_request(:get, "http://www.example.com/").status).to eq("200")
     end
 
     it "should return default response with empty message if response was not declared", :unless => (adapter_info.include?(:no_status_message)) do
       stub_request(:get, "www.example.com")
       response = http_request(:get, "http://www.example.com/")
-      response.message.should == ""
+      expect(response.message).to eq("")
     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.read(__FILE__)
+        expect(http_request(:get, "http://www.example.com/").body).to eq(File.read(__FILE__))
       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.read(__FILE__)
+          expect(http_request(:get, "http://www.example.com/").body).to eq(File.read(__FILE__))
         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
+        expect(@file).to 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"
+        expect(http_request(:post, "http://www.example.com/", :body => "echo").body).to eq("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'
-        http_request(:post, "http://www.example.com/", :body => "abc", :headers => {'A' => 'C'}).headers['A'].should == 'C'
+        expect(http_request(:post, "http://www.example.com/", :body => "abc", :headers => {'A' => 'B'}).headers['A']).to eq('B')
+        expect(http_request(:post, "http://www.example.com/", :body => "abc", :headers => {'A' => 'C'}).headers['A']).to eq('C')
       end
 
       it "should evaluate response body for each request" 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"
-        http_request(:post, "http://www.example.com/", :body => "foxtrot").body.should == "foxtrot"
+        expect(http_request(:post, "http://www.example.com/", :body => "echo").body).to eq("echo")
+        expect(http_request(:post, "http://www.example.com/", :body => "foxtrot").body).to eq("foxtrot")
       end
     end
 
@@ -138,27 +138,27 @@ shared_context "declared responses" do |*adapter_info|
         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"
-        http_request(:post, "http://www.example.com/", :body => "foxtrot").body.should == "foxtrot"
+        expect(http_request(:post, "http://www.example.com/", :body => "echo").body).to eq("echo")
+        expect(http_request(:post, "http://www.example.com/", :body => "foxtrot").body).to eq("foxtrot")
       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'
+        expect(http_request(:get, "http://www.example.com/", :headers => {'A' => 'B'}).headers['A']).to eq('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"
+        expect(http_request(:post, "http://www.example.com/", :body => "echo").body).to eq("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"
+        expect(http_request(:post, "http://www.example.com/", :body => "echo").body).to eq("echo")
       end
     end
 
@@ -171,29 +171,29 @@ shared_context "declared responses" do |*adapter_info|
       end
 
       it "should return recorded headers" do
-        @response.headers.should == {
+        expect(@response.headers).to eq({
           "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
+        expect(@response.body.size).to eq(419)
       end
 
       it "should return recorded status" do
-        @response.status.should == "202"
+        expect(@response.status).to eq("202")
       end
 
       it "should return recorded status message", :unless => (adapter_info.include?(:no_status_message)) do
-        @response.message.should == "OK"
+        expect(@response.message).to eq("OK")
       end
 
       it "should ensure file is closed" do
-        @file.should be_closed
+        expect(@file).to be_closed
       end
     end
 
@@ -205,25 +205,25 @@ shared_context "declared responses" do |*adapter_info|
       end
 
       it "should return recorded headers" do
-        @response.headers.should == {
+        expect(@response.headers).to eq({
           "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
+        expect(@response.body.size).to eq(419)
       end
 
       it "should return recorded status" do
-        @response.status.should == "202"
+        expect(@response.status).to eq("202")
       end
 
       it "should return recorded status message", :unless => (adapter_info.include?(:no_status_message)) do
-        @response.message.should == "OK"
+        expect(@response.message).to eq("OK")
       end
     end
 
@@ -236,24 +236,24 @@ shared_context "declared responses" do |*adapter_info|
 
       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
+        expect(http_request(:get, "http://www.example.com/").body.size).to eq(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
+        expect(http_request(:get, "http://www.example.com/").body.size).to eq(419)
       end
     end
 
     describe "when response is declared as an Rack app" do
       it "should return response returned by the rack app" do
         stub_request(:any, "http://www.example.com/greet").to_rack(MyRackApp)
-        http_request(:post, 'http://www.example.com/greet', :body => 'name=Jimmy').body.should == 'Good to meet you, Jimmy!'
+        expect(http_request(:post, 'http://www.example.com/greet', :body => 'name=Jimmy').body).to eq('Good to meet you, Jimmy!')
       end
 
       it "should pass along the port number to the rack app" do
         stub_request(:get, "http://www.example.com/compute").to_rack(MyRackApp)
-        http_request(:get, "http://www.example.com/compute").status.should == "200"
+        expect(http_request(:get, "http://www.example.com/compute").status).to eq("200")
       end
 
       it "preserves content-type header when proxying to a rack app" do
@@ -266,30 +266,30 @@ shared_context "declared responses" do |*adapter_info|
         }
 
         http_request(:get, url, :headers => headers)
-        WebMock.should have_requested(:get, url).with(:headers => headers)
+        expect(WebMock).to have_requested(:get, url).with(:headers => headers)
       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"
+        expect(http_request(:get, "http://www.example.com/").body).to eq("1")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("2")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("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"
+        expect(http_request(:get, "http://www.example.com/").body).to eq("1")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("2")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("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"
+        expect(http_request(:get, "http://www.example.com/").body).to eq("1")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("2")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("3")
       end
 
       it "should return responses one by one if declared with several to_return invokations" do
@@ -297,17 +297,17 @@ shared_context "declared responses" do |*adapter_info|
           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"
+        expect(http_request(:get, "http://www.example.com/").body).to eq("1")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("2")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("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"
+        expect(http_request(:get, "http://www.example.com/").body).to eq("1")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("2")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("3")
       end
 
     end
@@ -317,9 +317,9 @@ shared_context "declared responses" do |*adapter_info|
         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"
+        expect(http_request(:get, "http://www.example.com/").body).to eq("1")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("1")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("2")
       end
 
 
@@ -327,26 +327,26 @@ shared_context "declared responses" do |*adapter_info|
         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"
+        expect(http_request(:get, "http://www.example.com/").body).to eq("1")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("2")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("1")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("2")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("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"
+        expect(http_request(:get, "http://www.example.com/").body).to eq("1")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("1")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("1")
       end
 
       it "should give error if times is declared without specifying response" do
-        lambda {
+        expect {
           stub_request(:get, "www.example.com").times(3)
-        }.should raise_error("Invalid WebMock stub declaration. times(N) can be declared only after response declaration.")
+        }.to raise_error("Invalid WebMock stub declaration. times(N) can be declared only after response declaration.")
       end
 
     end
@@ -356,32 +356,32 @@ shared_context "declared responses" do |*adapter_info|
         stub_request(:get, "www.example.com").
           to_raise(MyException).times(2).
           to_return({:body => "2"})
-        lambda {
+        expect {
           http_request(:get, "http://www.example.com/")
-        }.should raise_error(MyException, "Exception from WebMock")
-        lambda {
+        }.to raise_error(MyException, "Exception from WebMock")
+        expect {
           http_request(:get, "http://www.example.com/")
-        }.should raise_error(MyException, "Exception from WebMock")
-        http_request(:get, "http://www.example.com/").body.should == "2"
+        }.to raise_error(MyException, "Exception from WebMock")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("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 {
+        expect {
           http_request(:get, "http://www.example.com/")
-        }.should raise_error(MyException, "Exception from WebMock")
-        lambda {
+        }.to raise_error(MyException, "Exception from WebMock")
+        expect {
           http_request(:get, "http://www.example.com/")
-        }.should raise_error(ArgumentError)
-        lambda {
+        }.to raise_error(ArgumentError)
+        expect {
           http_request(:get, "http://www.example.com/")
-        }.should raise_error(MyException, "Exception from WebMock")
-        lambda {
+        }.to raise_error(MyException, "Exception from WebMock")
+        expect {
           http_request(:get, "http://www.example.com/")
-        }.should raise_error(ArgumentError)
-        http_request(:get, "http://www.example.com/").body.should == "2"
+        }.to raise_error(ArgumentError)
+        expect(http_request(:get, "http://www.example.com/").body).to eq("2")
       end
     end
   end

data/spec/acceptance/shared/stubbing_requests.rb

@@ -5,37 +5,37 @@ shared_examples_for "stubbing requests" do |*adapter_info|
     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%2B/?#{ESCAPED_PARAMS}").body.should == "abc"
+        expect(http_request(:get, "http://www.example.com/hello%2B/?#{ESCAPED_PARAMS}").body).to eq("abc")
       end
 
       it "should return stubbed response even if query params have integer values" do
         stub_request(:get, "www.example.com").with(:query => {"a" => 1}).to_return(:body => "abc")
-        http_request(:get, "http://www.example.com/?a=1").body.should == "abc"
+        expect(http_request(:get, "http://www.example.com/?a=1").body).to eq("abc")
       end
 
       it "should return stubbed response even if request has non escaped params" do
         stub_request(:get, "www.example.com/hello%2B/?#{ESCAPED_PARAMS}").to_return(:body => "abc")
-        http_request(:get, "http://www.example.com/hello+/?#{NOT_ESCAPED_PARAMS}").body.should == "abc"
+        expect(http_request(:get, "http://www.example.com/hello+/?#{NOT_ESCAPED_PARAMS}").body).to eq("abc")
       end
 
       it "should return stubbed response for url with non utf query params", "ruby>1.9" => true do
         param = 'aäoöuü'.encode('iso-8859-1')
         param = CGI.escape(param)
         stub_request(:get, "www.example.com/?#{param}").to_return(:body => "abc")
-        http_request(:get, "http://www.example.com/?#{param}").body.should == "abc"
+        expect(http_request(:get, "http://www.example.com/?#{param}").body).to eq("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"
+        expect(http_request(:get, "http://www.example.com/hello/?#{ESCAPED_PARAMS}").body).to eq("abc")
       end
 
       it "should raise error specifying stubbing instructions with escaped characters in params if there is no matching stub" do
         begin
           http_request(:get, "http://www.example.com/hello+/?#{NOT_ESCAPED_PARAMS}")
         rescue WebMock::NetConnectNotAllowedError => e
-          e.message.should match /Unregistered request: GET http:\/\/www\.example\.com\/hello\+\/\?x=ab%20c&z='Stop!'%20said%20Fred%20m/m
-          e.message.should match /stub_request\(:get, "http:\/\/www\.example\.com\/hello\+\/\?x=ab%20c&z='Stop!'%20said%20Fred%20m"\)/m
+          expect(e.message).to match /Unregistered request: GET http:\/\/www\.example\.com\/hello\+\/\?x=ab%20c&z='Stop!'%20said%20Fred%20m/m
+          expect(e.message).to match /stub_request\(:get, "http:\/\/www\.example\.com\/hello\+\/\?x=ab%20c&z='Stop!'%20said%20Fred%20m"\)/m
         end
 
         stub_request(:get, "http://www.example.com/hello+/?x=ab%20c&z='Stop!'%20said%20Fred%20m")
@@ -46,42 +46,42 @@ shared_examples_for "stubbing requests" do |*adapter_info|
     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 x", "c d"]}).to_return(:body => "abc")
-        http_request(:get, "http://www.example.com/?a[]=b+x&a[]=c%20d").body.should == "abc"
+        expect(http_request(:get, "http://www.example.com/?a[]=b+x&a[]=c%20d").body).to eq("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"
+        expect(http_request(:get, "http://www.example.com/?a[]=b&a[]=c").body).to eq("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"
+        expect(http_request(:get, "http://www.example.com/?x=3&a[]=b&a[]=c").body).to eq("abc")
       end
 
       it "should return stubbed response when stub expects only part of query params" do
         stub_request(:get, "www.example.com").with(:query => hash_including({"a" => ["b", "c"]})).to_return(:body => "abc")
-        http_request(:get, "http://www.example.com/?a[]=b&a[]=c&b=1").body.should == "abc"
+        expect(http_request(:get, "http://www.example.com/?a[]=b&a[]=c&b=1").body).to eq("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"
+        expect(http_request(:get, "http://www.example.com/").status).to eq("200")
       end
 
       it "should match stubbed request when http request was made with method given as string" do
         stub_request(:get, "www.example.com")
-        http_request('get', "http://www.example.com/").status.should == "200"
+        expect(http_request('get', "http://www.example.com/").status).to eq("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 {
+        expect(http_request(:get, "http://www.example.com/").status).to eq("200")
+        expect {
           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/)
+        }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: DELETE http://www.example.com/)
                              )
       end
     end
@@ -89,38 +89,38 @@ shared_examples_for "stubbing requests" do |*adapter_info|
     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(
+        expect(http_request(
           :post, "http://www.example.com/",
-        :body => "abc").status.should == "200"
+        :body => "abc").status).to eq("200")
       end
 
       it "should match requests if body is not set in the stub" do
         stub_request(:post, "www.example.com")
-        http_request(
+        expect(http_request(
           :post, "http://www.example.com/",
-        :body => "abc").status.should == "200"
+        :body => "abc").status).to eq("200")
       end
 
       it "should not match requests if body is different" do
         stub_request(:post, "www.example.com").with(:body => "abc")
-        lambda {
+        expect {
           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'))
+        }.to 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(
+          expect(http_request(
             :post, "http://www.example.com/",
-          :body => "123abc").status.should == "200"
+          :body => "123abc").status).to eq("200")
         end
 
         it "should not match requests if body doesn't match regexp" do
           stub_request(:post, "www.example.com").with(:body => /^abc/)
-          lambda {
+          expect {
             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'))
+          }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: POST http://www.example.com/ with body 'xabc'))
         end
       end
 
@@ -132,55 +132,55 @@ shared_examples_for "stubbing requests" do |*adapter_info|
 
         describe "for request with url encoded body" do
           it "should match request if hash matches body" do
-            http_request(
+            expect(http_request(
               :post, "http://www.example.com/",
-            :body => 'a=1&c[d][]=e&c[d][]=f&b=five+x').status.should == "200"
+            :body => 'a=1&c[d][]=e&c[d][]=f&b=five+x').status).to eq("200")
           end
 
           it "should match request if hash matches body in different order of params" do
-            http_request(
+            expect(http_request(
               :post, "http://www.example.com/",
-            :body => 'a=1&c[d][]=e&b=five+x&c[d][]=f').status.should == "200"
+            :body => 'a=1&c[d][]=e&b=five+x&c[d][]=f').status).to eq("200")
           end
 
           it "should not match if hash doesn't match url encoded body" do
-            lambda {
+            expect {
               http_request(
                 :post, "http://www.example.com/",
               :body => 'c[d][]=f&a=1&c[d][]=e')
-            }.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'))
+            }.to 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(
+            expect(http_request(
               :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
-            :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five x\"}").status.should == "200"
+            :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five x\"}").status).to eq("200")
           end
 
           it "should match if hash matches body in different form" do
-            http_request(
+            expect(http_request(
               :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
-            :body => "{\"a\":\"1\",\"b\":\"five x\",\"c\":{\"d\":[\"e\",\"f\"]}}").status.should == "200"
+            :body => "{\"a\":\"1\",\"b\":\"five x\",\"c\":{\"d\":[\"e\",\"f\"]}}").status).to eq("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(
+            expect(http_request(
               :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
-            :body => "{\"foo\":\"2010-01-01\"}").status.should == "200"
+            :body => "{\"foo\":\"2010-01-01\"}").status).to eq("200")
           end
 
           it "should match if any of the strings have spaces" do
             WebMock.reset!
             stub_request(:post, "www.example.com").with(:body => {"foo" => "a b c"})
-            http_request(
+            expect(http_request(
               :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
-            :body => "{\"foo\":\"a b c\"}").status.should == "200"
+            :body => "{\"foo\":\"a b c\"}").status).to eq("200")
           end
         end
 
@@ -192,24 +192,24 @@ shared_examples_for "stubbing requests" do |*adapter_info|
           end
 
           it "should match if hash matches body" do
-            http_request(
+            expect(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"
+            :body => "<opt a=\"1\" b=\"five\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n").status).to eq("200")
           end
 
           it "should match if hash matches body in different form" do
-            http_request(
+            expect(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"
+            :body => "<opt b=\"five\" a=\"1\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n").status).to eq("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(
+            expect(http_request(
               :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
-            :body => "<opt foo=\"2010-01-01\">\n</opt>\n").status.should == "200"
+            :body => "<opt foo=\"2010-01-01\">\n</opt>\n").status).to eq("200")
           end
         end
       end
@@ -233,15 +233,15 @@ shared_examples_for "stubbing requests" do |*adapter_info|
             end
 
             it "should not match if hash doesn't match url encoded body" do
-              lambda { wrong_request }.should raise_error
+              expect { wrong_request }.to raise_error
             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(
+              expect(http_request(
                 :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
-              :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}").status.should == "200"
+              :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}").status).to eq("200")
             end
           end
         end
@@ -258,15 +258,15 @@ shared_examples_for "stubbing requests" do |*adapter_info|
             end
 
             it "should not match if hash doesn't match url encoded body" do
-              lambda { wrong_request }.should raise_error
+              expect { wrong_request }.to raise_error
             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(
+              expect(http_request(
                 :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
-              :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}").status.should == "200"
+              :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}").status).to eq("200")
             end
           end
         end
@@ -277,87 +277,87 @@ shared_examples_for "stubbing requests" do |*adapter_info|
     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(
+        expect(http_request(
           :get, "http://www.example.com/",
-        :headers => SAMPLE_HEADERS).status.should == "200"
+        :headers => SAMPLE_HEADERS).status).to eq("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(
+        expect(http_request(
           :get, "http://www.example.com/",
-        :headers => {"a" => "b"}).status.should == "200"
+        :headers => {"a" => "b"}).status).to eq("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(
+          expect(http_request(
             :get, "http://www.example.com/",
-          :headers => {"a" => ["b", "c"]}).status.should == "200"
+          :headers => {"a" => ["b", "c"]}).status).to eq("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(
+          expect(http_request(
             :get, "http://www.example.com/",
-          :headers => {"a" => ["c", "b"]}).status.should == "200"
+          :headers => {"a" => ["c", "b"]}).status).to eq("200")
         end
 
         it "should not match requests if headers are different" do
           stub_request(:get, "www.example.com").with(:headers => {"a" => ["b", "c"]})
 
-          lambda {
+          expect {
             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))
+          }.to 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(
+        expect(http_request(
           :get, "http://www.example.com/",
-        :headers => SAMPLE_HEADERS).status.should == "200"
+        :headers => SAMPLE_HEADERS).status).to eq("200")
       end
 
       it "should not match requests if headers are different" do
         stub_request(:get, "www.example.com").with(:headers => SAMPLE_HEADERS)
 
-        lambda {
+        expect {
           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))
+        }.to 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 {
+        expect {
           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))
+        }.to 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(
+          expect(http_request(
             :get, "http://www.example.com/",
-          :headers => { 'some-header' => 'MyAppName' }).status.should == "200"
+          :headers => { 'some-header' => 'MyAppName' }).status).to eq("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 {
+          expect {
             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))
+          }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/ with headers))
         end
       end
     end
@@ -365,28 +365,28 @@ shared_examples_for "stubbing requests" do |*adapter_info|
     describe "when stubbing request with basic authentication", :unless => (adapter_info.include?(:no_url_auth)) 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"
+        expect(http_request(:get, "http://user:pass@www.example.com/").status).to eq("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/))
+        expect {
+          expect(http_request(:get, "http://user:pazz@www.example.com/").status).to eq("200")
+        }.to 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/))
+        expect {
+          expect(http_request(:get, "http://www.example.com/").status).to eq("200")
+        }.to 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/))
+        expect {
+          expect(http_request(:get, "http://user:pazz@www.example.com/").status).to eq("200")
+        }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://user:pazz@www.example.com/))
       end
     end
 
@@ -400,7 +400,7 @@ shared_examples_for "stubbing requests" do |*adapter_info|
           { :body => "global stub body" }
         end
 
-        http_request(:get, "http://www.example.com/").body.should == "global stub body"
+        expect(http_request(:get, "http://www.example.com/").body).to eq("global stub body")
       end
 
       it 'does not get cleared when a user calls WebMock.reset!' do
@@ -408,14 +408,14 @@ shared_examples_for "stubbing requests" do |*adapter_info|
           { :body => "global stub body" }
         end
         WebMock.reset!
-        http_request(:get, "http://www.example.com/").body.should == "global stub body"
+        expect(http_request(:get, "http://www.example.com/").body).to eq("global stub body")
       end
 
       it "does not stub the request if the hook does not return anything" do
         WebMock.globally_stub_request { |r| }
-        lambda {
+        expect {
           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/))
+        }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
       end
 
       it "passes the request to the block" do
@@ -426,7 +426,7 @@ shared_examples_for "stubbing requests" do |*adapter_info|
         end
 
         http_request(:get, "http://www.example.com:456/bar")
-        passed_request.uri.to_s.should == "http://www.example.com:456/bar"
+        expect(passed_request.uri.to_s).to eq("http://www.example.com:456/bar")
       end
 
       it "should call the block only once per request" do
@@ -436,7 +436,7 @@ shared_examples_for "stubbing requests" do |*adapter_info|
           { :body => "global stub body" }
         end
         http_request(:get, "http://www.example.com/")
-        call_count.should == 1
+        expect(call_count).to eq(1)
       end
 
       it 'supports multiple global stubs; the first registered one that returns a non-nil value determines the stub' do
@@ -451,8 +451,8 @@ shared_examples_for "stubbing requests" do |*adapter_info|
           { :body => "global stub body" }
         end
 
-        http_request(:get, "http://www.example.com/").body.should == "global stub body"
-        stub_invocation_order.should eq([:nil_stub, :hash_stub])
+        expect(http_request(:get, "http://www.example.com/").body).to eq("global stub body")
+        expect(stub_invocation_order).to eq([:nil_stub, :hash_stub])
       end
 
       [:before, :after].each do |before_or_after|
@@ -469,12 +469,12 @@ shared_examples_for "stubbing requests" do |*adapter_info|
 
           it 'uses the response from the global stub if the block returns a non-nil value' do
             register_stubs(lambda { |req| { :body => 'global stub body' } })
-            http_request(:get, "http://www.example.com/").body.should == "global stub body"
+            expect(http_request(:get, "http://www.example.com/").body).to eq("global stub body")
           end
 
           it 'uses the response from the non-global stub if the block returns a nil value' do
             register_stubs(lambda { |req| nil })
-            http_request(:get, "http://www.example.com/").body.should == "non-global stub body"
+            expect(http_request(:get, "http://www.example.com/").body).to eq("non-global stub body")
           end
         end
       end
@@ -483,31 +483,31 @@ shared_examples_for "stubbing requests" do |*adapter_info|
     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"
+        expect(http_request(:get, "http://www.example.com/").status).to eq("200")
       end
 
       it "should not match if block returns false" do
         stub_request(:get, "www.example.com").with { |request| false }
-        lambda {
+        expect {
           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/))
+        }.to 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(
+        expect(http_request(
           :post, "http://www.example.com/",
-        :body => "wadus").status.should == "200"
-        lambda {
+        :body => "wadus").status).to eq("200")
+        expect {
           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'))
+        }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: POST http://www.example.com/ with body 'jander'))
       end
 
       it "should call the block only once per request" do
         call_count = 0
         stub_request(:get, "www.example.com").with { |request| call_count += 1; true }
-        http_request(:get, "http://www.example.com/").status.should == "200"
-        call_count.should == 1
+        expect(http_request(:get, "http://www.example.com/").status).to eq("200")
+        expect(call_count).to eq(1)
       end
     end
   end
@@ -520,9 +520,9 @@ shared_examples_for "stubbing requests" do |*adapter_info|
 
       remove_request_stub(stub)
 
-      lambda {
+      expect {
         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/))
+      }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
     end
   end
 end