webmock 2.0.3 → 2.1.0

data/spec/acceptance/shared/returning_declared_responses.rb

@@ -2,7 +2,7 @@ class MyException < StandardError; end;
 
 class Responder
   def call(request)
-    {:body => request.body}
+    {body: request.body}
   end
 end
 
@@ -30,7 +30,7 @@ shared_context "declared responses" do |*adapter_info|
     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)
+      stub_request(:get, "www.example.com").to_return(body: "abc").then.to_raise(MyException)
       expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
       expect {
         http_request(:get, "http://www.example.com/")
@@ -47,7 +47,7 @@ shared_context "declared responses" do |*adapter_info|
     end
 
     it "should timeout after returning declared successful response" do
-      stub_request(:get, "www.example.com").to_return(:body => "abc").then.to_timeout
+      stub_request(:get, "www.example.com").to_return(body: "abc").then.to_timeout
       expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
       expect {
         http_request(:get, "http://www.example.com/")
@@ -57,29 +57,29 @@ shared_context "declared responses" do |*adapter_info|
 
   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")
+      stub_request(:get, "www.example.com").to_return(body: "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)
+      stub_request(:get, "www.example.com").to_return(headers: SAMPLE_HEADERS)
       response = http_request(:get, "http://www.example.com/")
       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"]})
+      stub_request(:get, "www.example.com").to_return(headers: {"a" => ["b", "c"]})
       response = http_request(:get, "http://www.example.com/")
       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)
+      stub_request(:get, "www.example.com").to_return(status: 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"])
+    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/")
       expect(response.message).to eq("Internal Server Error")
     end
@@ -89,7 +89,7 @@ shared_context "declared responses" do |*adapter_info|
       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
+    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/")
       expect(response.message).to eq("")
@@ -97,68 +97,68 @@ shared_context "declared responses" do |*adapter_info|
 
     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__))
+        stub_request(:get, "www.example.com").to_return(body: File.new(__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__))
+        stub_request(:get, "www.example.com").to_return(body: File.new(__FILE__))
         2.times do
           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__))
+        stub_request(:get, "www.example.com").to_return(body: @file = File.new(__FILE__))
         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 })
-        expect(http_request(:post, "http://www.example.com/", :body => "echo").body).to eq("echo")
+        stub_request(:post, "www.example.com").to_return(body: lambda { |request| request.body })
+        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 })
-        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')
+        stub_request(:post, "www.example.com").to_return(headers: lambda { |request| request.headers })
+        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 })
-        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")
+        stub_request(:post, "www.example.com").to_return(body: lambda { |request| request.body })
+        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
 
     describe "when response was declared as lambda" do
       it "should return evaluated response body" do
         stub_request(:post, "www.example.com").to_return(lambda {|request|
-                                                                {:body => request.body}
+                                                                {body: request.body}
         })
-        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")
+        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}
+                                                               {headers: request.headers}
         })
-        expect(http_request(:get, "http://www.example.com/", :headers => {'A' => 'B'}).headers['A']).to eq('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}
+          {body: request.body}
         end
-        expect(http_request(:post, "http://www.example.com/", :body => "echo").body).to eq("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)
-        expect(http_request(:post, "http://www.example.com/", :body => "echo").body).to eq("echo")
+        expect(http_request(:post, "http://www.example.com/", body: "echo").body).to eq("echo")
       end
     end
 
@@ -188,7 +188,7 @@ shared_context "declared responses" do |*adapter_info|
         expect(@response.status).to eq("202")
       end
 
-      it "should return recorded status message", :unless => (adapter_info.include?(:no_status_message)) do
+      it "should return recorded status message", unless: (adapter_info.include?(:no_status_message)) do
         expect(@response.message).to eq("OK")
       end
 
@@ -222,7 +222,7 @@ shared_context "declared responses" do |*adapter_info|
         expect(@response.status).to eq("202")
       end
 
-      it "should return recorded status message", :unless => (adapter_info.include?(:no_status_message)) do
+      it "should return recorded status message", unless: (adapter_info.include?(:no_status_message)) do
         expect(@response.message).to eq("OK")
       end
     end
@@ -248,7 +248,7 @@ shared_context "declared responses" do |*adapter_info|
     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)
-        expect(http_request(:post, 'http://www.example.com/greet', :body => 'name=Jimmy').body).to eq('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
@@ -265,28 +265,28 @@ shared_context "declared responses" do |*adapter_info|
           "Content-Type" => "application/json"
         }
 
-        http_request(:get, url, :headers => headers)
-        expect(WebMock).to have_requested(:get, url).with(:headers => headers)
+        http_request(:get, url, 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"} ])
+        stub_request(:get, "www.example.com").to_return([ {body: "1"}, {body: "2"}, {body: "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"} ])
+        stub_request(:get, "www.example.com").to_return([ {body: "1"}, {body: "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"})
+        stub_request(:get, "www.example.com").to_return({body: "1"}, {body: "2"}, {body: "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")
@@ -294,17 +294,17 @@ shared_context "declared responses" do |*adapter_info|
 
       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"})
+          to_return({body: "1"}).
+          to_return({body: "2"}).
+          to_return({body: "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"})
+        stub_request(:get, "www.example.com").to_return({body: "1"}).then.
+          to_return({body: "2"}).then.to_return({body: "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")
@@ -315,8 +315,8 @@ shared_context "declared responses" do |*adapter_info|
     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"})
+          to_return({body: "1"}).times(2).
+          to_return({body: "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")
@@ -325,8 +325,8 @@ shared_context "declared responses" do |*adapter_info|
 
       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"})
+          to_return({body: "1"}, {body: "2"}).times(2).
+          to_return({body: "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")
@@ -337,7 +337,7 @@ shared_context "declared responses" do |*adapter_info|
 
       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)
+          to_return({body: "1"}).times(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("1")
@@ -355,7 +355,7 @@ shared_context "declared responses" do |*adapter_info|
       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"})
+          to_return({body: "2"})
         expect {
           http_request(:get, "http://www.example.com/")
         }.to raise_error(MyException, "Exception from WebMock")
@@ -368,7 +368,7 @@ shared_context "declared responses" do |*adapter_info|
       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"})
+          to_return({body: "2"})
         expect {
           http_request(:get, "http://www.example.com/")
         }.to raise_error(MyException, "Exception from WebMock")

data/spec/acceptance/shared/stubbing_requests.rb

@@ -4,29 +4,29 @@ shared_examples_for "stubbing requests" do |*adapter_info|
   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")
+        stub_request(:get, "www.example.com/hello+/?#{NOT_ESCAPED_PARAMS}").to_return(body: "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")
+        stub_request(:get, "www.example.com").with(query: {"a" => 1}).to_return(body: "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")
+        stub_request(:get, "www.example.com/hello%2B/?#{ESCAPED_PARAMS}").to_return(body: "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")
+        stub_request(:get, "www.example.com/?#{param}").to_return(body: "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")
+        stub_request(:get, /.*x=ab c.*/).to_return(body: "abc")
         expect(http_request(:get, "http://www.example.com/hello/?#{ESCAPED_PARAMS}").body).to eq("abc")
       end
 
@@ -45,22 +45,22 @@ 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")
+        stub_request(:get, "www.example.com").with(query: {"a" => ["b x", "c d"]}).to_return(body: "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")
+        stub_request(:get, "www.example.com").with(query: "a[]=b&a[]=c").to_return(body: "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")
+        stub_request(:get, "www.example.com/?x=3").with(query: {"a" => ["b", "c"]}).to_return(body: "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")
+        stub_request(:get, "www.example.com").with(query: hash_including({"a" => ["b", "c"]})).to_return(body: "abc")
         expect(http_request(:get, "http://www.example.com/?a[]=b&a[]=c&b=1").body).to eq("abc")
       end
     end
@@ -88,38 +88,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")
+        stub_request(:post, "www.example.com").with(body: "abc")
         expect(http_request(
           :post, "http://www.example.com/",
-        :body => "abc").status).to eq("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")
         expect(http_request(
           :post, "http://www.example.com/",
-        :body => "abc").status).to eq("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")
+        stub_request(:post, "www.example.com").with(body: "abc")
         expect {
-          http_request(:post, "http://www.example.com/", :body => "def")
+          http_request(:post, "http://www.example.com/", 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$/)
+          stub_request(:post, "www.example.com").with(body: /\d+abc$/)
           expect(http_request(
             :post, "http://www.example.com/",
-          :body => "123abc").status).to eq("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/)
+          stub_request(:post, "www.example.com").with(body: /^abc/)
           expect {
-            http_request(:post, "http://www.example.com/", :body => "xabc")
+            http_request(:post, "http://www.example.com/", 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
@@ -127,27 +127,27 @@ shared_examples_for "stubbing requests" do |*adapter_info|
       describe "when body is declared as a hash" do
         before(:each) do
           stub_request(:post, "www.example.com").
-            with(:body => {:a => '1', :b => 'five x', 'c' => {'d' => ['e', 'f']} })
+            with(body: {:a => '1', :b => 'five x', 'c' => {'d' => ['e', 'f']} })
         end
 
         describe "for request with url encoded body" do
           it "should match request if hash matches body" do
             expect(http_request(
               :post, "http://www.example.com/",
-            :body => 'a=1&c[d][]=e&c[d][]=f&b=five+x').status).to eq("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
             expect(http_request(
               :post, "http://www.example.com/",
-            :body => 'a=1&c[d][]=e&b=five+x&c[d][]=f').status).to eq("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
             expect {
               http_request(
                 :post, "http://www.example.com/",
-              :body => 'c[d][]=f&a=1&c[d][]=e')
+              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
@@ -156,31 +156,31 @@ shared_examples_for "stubbing requests" do |*adapter_info|
         describe "for request with json body and content type is set to json" do
           it "should match if hash matches body" do
             expect(http_request(
-              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
-            :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five x\"}").status).to eq("200")
+              :post, "http://www.example.com/", headers: {'Content-Type' => 'application/json'},
+            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
             expect(http_request(
-              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
-            :body => "{\"a\":\"1\",\"b\":\"five x\",\"c\":{\"d\":[\"e\",\"f\"]}}").status).to eq("200")
+              :post, "http://www.example.com/", headers: {'Content-Type' => 'application/json'},
+            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"})
+              with(body: {"foo" => "2010-01-01"})
             expect(http_request(
-              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
-            :body => "{\"foo\":\"2010-01-01\"}").status).to eq("200")
+              :post, "http://www.example.com/", headers: {'Content-Type' => 'application/json'},
+            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"})
+            stub_request(:post, "www.example.com").with(body: {"foo" => "a b c"})
             expect(http_request(
-              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
-            :body => "{\"foo\":\"a b c\"}").status).to eq("200")
+              :post, "http://www.example.com/", headers: {'Content-Type' => 'application/json'},
+            body: "{\"foo\":\"a b c\"}").status).to eq("200")
           end
         end
 
@@ -188,43 +188,43 @@ shared_examples_for "stubbing requests" do |*adapter_info|
           before(:each) do
             WebMock.reset!
             stub_request(:post, "www.example.com").
-              with(:body => { "opt" => {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']} }})
+              with(body: { "opt" => {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']} }})
           end
 
           it "should match if hash matches body" do
             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).to eq("200")
+              :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).to eq("200")
           end
 
           it "should match if hash matches body in different form" do
             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).to eq("200")
+              :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).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"}})
+              with(body: {"opt" => {"foo" => "2010-01-01"}})
             expect(http_request(
-              :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
-            :body => "<opt foo=\"2010-01-01\">\n</opt>\n").status).to eq("200")
+              :post, "http://www.example.com/", headers: {'Content-Type' => 'application/xml'},
+            body: "<opt foo=\"2010-01-01\">\n</opt>\n").status).to eq("200")
           end
         end
       end
 
       describe "when body is declared as partial hash matcher" do
         subject(:request) { http_request( :post, "http://www.example.com/",
-                                :body => 'a=1&c[d][]=e&c[d][]=f&b=five') }
+                                body: 'a=1&c[d][]=e&c[d][]=f&b=five') }
 
         subject(:wrong_request) { http_request(:post, "http://www.example.com/",
-                                      :body => 'c[d][]=f&a=1&c[d][]=e').status }
+                                      body: 'c[d][]=f&a=1&c[d][]=e').status }
 
         describe "when using 'RSpec:Mocks::ArgumentMatchers#hash_including'" do
           before(:each) do
             stub_request(:post, "www.example.com").
-              with(:body => hash_including(:a, :c => {'d' => ['e', 'f']} ))
+              with(body: hash_including(:a, c: {'d' => ['e', 'f']} ))
           end
 
           describe "for request with url encoded body" do
@@ -240,8 +240,8 @@ shared_examples_for "stubbing requests" do |*adapter_info|
           describe "for request with json body and content type is set to json" do
             it "should match if hash matches body" do
               expect(http_request(
-                :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
-              :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}").status).to eq("200")
+                :post, "http://www.example.com/", headers: {'Content-Type' => 'application/json'},
+              body: "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}").status).to eq("200")
             end
           end
         end
@@ -249,7 +249,7 @@ shared_examples_for "stubbing requests" do |*adapter_info|
         describe "when using 'WebMock::API#hash_including'" do
           before(:each) do
             stub_request(:post, "www.example.com").
-              with(:body => WebMock::API.hash_including(:a, :c => {'d' => ['e', 'f']} ))
+              with(body: WebMock::API.hash_including(:a, c: {'d' => ['e', 'f']} ))
           end
 
           describe "for request with url encoded body" do
@@ -265,8 +265,8 @@ shared_examples_for "stubbing requests" do |*adapter_info|
           describe "for request with json body and content type is set to json" do
             it "should match if hash matches body" do
               expect(http_request(
-                :post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
-              :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}").status).to eq("200")
+                :post, "http://www.example.com/", headers: {'Content-Type' => 'application/json'},
+              body: "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}").status).to eq("200")
             end
           end
         end
@@ -276,41 +276,41 @@ 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 )
+        stub_request(:get, "www.example.com").with(headers: SAMPLE_HEADERS )
         expect(http_request(
           :get, "http://www.example.com/",
-        :headers => SAMPLE_HEADERS).status).to eq("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"]} )
+        stub_request(:get, "www.example.com").with(headers: {"a" => ["b"]} )
         expect(http_request(
           :get, "http://www.example.com/",
-        :headers => {"a" => "b"}).status).to eq("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"]} )
+          stub_request(:get, "www.example.com").with(headers: {"a" => ["b", "c"]} )
           expect(http_request(
             :get, "http://www.example.com/",
-          :headers => {"a" => ["b", "c"]}).status).to eq("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"]} )
+          stub_request(:get, "www.example.com").with(headers: {"a" => ["b", "c"]} )
           expect(http_request(
             :get, "http://www.example.com/",
-          :headers => {"a" => ["c", "b"]}).status).to eq("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"]})
+          stub_request(:get, "www.example.com").with(headers: {"a" => ["b", "c"]})
 
           expect {
             http_request(
               :get, "http://www.example.com/",
-            :headers => {"a" => ["b", "d"]})
+            headers: {"a" => ["b", "d"]})
           }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/ with headers))
         end
       end
@@ -319,50 +319,50 @@ shared_examples_for "stubbing requests" do |*adapter_info|
         stub_request(:get, "www.example.com")
         expect(http_request(
           :get, "http://www.example.com/",
-        :headers => SAMPLE_HEADERS).status).to eq("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)
+        stub_request(:get, "www.example.com").with(headers: SAMPLE_HEADERS)
 
         expect {
           http_request(
             :get, "http://www.example.com/",
-          :headers => { 'Content-Length' => '9999'})
+          headers: { 'Content-Length' => '9999'})
         }.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'})
+          with(headers: { 'Accept' => 'application/json'})
         expect {
           http_request(
             :get, "http://www.example.com/",
-          :headers => { 'Accept' => 'application/xml'})
+          headers: { 'Accept' => 'application/xml'})
         }.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$/ })
+          stub_request(:get, "www.example.com").with(headers: { some_header: /^MyAppName$/ })
           expect(http_request(
             :get, "http://www.example.com/",
-          :headers => { 'some-header' => 'MyAppName' }).status).to eq("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$/ })
+          stub_request(:get, "www.example.com").with(headers: { some_header: /^MyAppName$/ })
 
           expect {
             http_request(
               :get, "http://www.example.com/",
-            :headers => { 'some-header' => 'xMyAppName' })
+            headers: { 'some-header' => 'xMyAppName' })
           }.to 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 userinfo in url", :unless => (adapter_info.include?(:no_url_auth)) do
+    describe "when stubbing request with userinfo in url", 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")
         expect(http_request(:get, "http://user:pass@www.example.com/").status).to eq("200")
@@ -437,7 +437,7 @@ shared_examples_for "stubbing requests" do |*adapter_info|
         expect(http_request(:get, "http://www.example.com/", basic_auth: ['user', 'pass']).status).to eq("200")
       end
 
-      it "should not match if request has credentials provides in userinfo", :unless => (adapter_info.include?(:no_url_auth)) do
+      it "should not match if request has credentials provides in userinfo", unless: (adapter_info.include?(:no_url_auth)) do
         stub_request(:get, "www.example.com").with(basic_auth: ['user', 'pass'])
         expect {
           expect(http_request(:get, "http://user:pass@www.example.com/").status).to eq("200")
@@ -452,7 +452,7 @@ shared_examples_for "stubbing requests" do |*adapter_info|
 
       it 'returns the response returned by the hook' do
         WebMock.globally_stub_request do |request|
-          { :body => "global stub body" }
+          { body: "global stub body" }
         end
 
         expect(http_request(:get, "http://www.example.com/").body).to eq("global stub body")
@@ -460,7 +460,7 @@ shared_examples_for "stubbing requests" do |*adapter_info|
 
       it 'does not get cleared when a user calls WebMock.reset!' do
         WebMock.globally_stub_request do |request|
-          { :body => "global stub body" }
+          { body: "global stub body" }
         end
         WebMock.reset!
         expect(http_request(:get, "http://www.example.com/").body).to eq("global stub body")
@@ -477,7 +477,7 @@ shared_examples_for "stubbing requests" do |*adapter_info|
         passed_request = nil
         WebMock.globally_stub_request do |request|
           passed_request = request
-          { :body => "global stub body" }
+          { body: "global stub body" }
         end
 
         http_request(:get, "http://www.example.com:456/bar")
@@ -488,7 +488,7 @@ shared_examples_for "stubbing requests" do |*adapter_info|
         call_count = 0
         WebMock.globally_stub_request do |request|
           call_count += 1
-          { :body => "global stub body" }
+          { body: "global stub body" }
         end
         http_request(:get, "http://www.example.com/")
         expect(call_count).to eq(1)
@@ -503,7 +503,7 @@ shared_examples_for "stubbing requests" do |*adapter_info|
 
         WebMock.globally_stub_request do |request|
           stub_invocation_order << :hash_stub
-          { :body => "global stub body" }
+          { body: "global stub body" }
         end
 
         expect(http_request(:get, "http://www.example.com/").body).to eq("global stub body")
@@ -513,7 +513,7 @@ shared_examples_for "stubbing requests" do |*adapter_info|
       [:before, :after].each do |before_or_after|
         context "when there is also a non-global registered stub #{before_or_after} the global stub" do
           def stub_non_globally
-            stub_request(:get, "www.example.com").to_return(:body => 'non-global stub body')
+            stub_request(:get, "www.example.com").to_return(body: 'non-global stub body')
           end
 
           define_method :register_stubs do |block|
@@ -523,7 +523,7 @@ shared_examples_for "stubbing requests" do |*adapter_info|
           end
 
           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' } })
+            register_stubs(lambda { |req| { body: 'global stub body' } })
             expect(http_request(:get, "http://www.example.com/").body).to eq("global stub body")
           end
 
@@ -552,9 +552,9 @@ shared_examples_for "stubbing requests" do |*adapter_info|
         stub_request(:post, "www.example.com").with { |request| request.body == "wadus" }
         expect(http_request(
           :post, "http://www.example.com/",
-        :body => "wadus").status).to eq("200")
+        body: "wadus").status).to eq("200")
         expect {
-          http_request(:post, "http://www.example.com/", :body => "jander")
+          http_request(:post, "http://www.example.com/", body: "jander")
         }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: POST http://www.example.com/ with body 'jander'))
       end