webmock 2.0.3 → 2.1.0

data/lib/webmock/util/uri.rb

@@ -14,8 +14,8 @@ module WebMock
       NORMALIZED_URIS = Hash.new do |hash, uri|
         normalized_uri = WebMock::Util::URI.heuristic_parse(uri)
         if normalized_uri.query_values
-          sorted_query_values = sort_query_values(WebMock::Util::QueryMapper.query_to_values(normalized_uri.query, :notation => Config.instance.query_values_notation) || {})
-          normalized_uri.query = WebMock::Util::QueryMapper.values_to_query(sorted_query_values, :notation => WebMock::Config.instance.query_values_notation)
+          sorted_query_values = sort_query_values(WebMock::Util::QueryMapper.query_to_values(normalized_uri.query, notation: Config.instance.query_values_notation) || {})
+          normalized_uri.query = WebMock::Util::QueryMapper.values_to_query(sorted_query_values, notation: WebMock::Config.instance.query_values_notation)
         end
         normalized_uri = normalized_uri.normalize #normalize! is slower
         normalized_uri.query = normalized_uri.query.gsub("+", "%2B") if normalized_uri.query

data/lib/webmock/version.rb

@@ -1,3 +1,3 @@
 module WebMock
-  VERSION = '2.0.3' unless defined?(::WebMock::VERSION)
+  VERSION = '2.1.0' unless defined?(::WebMock::VERSION)
 end

data/minitest/webmock_spec.rb

@@ -25,20 +25,20 @@ require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
     it "should verify that expected request occured" do
       http_request(:get, "http://www.example.com/")
-      assert_requested(:get, "http://www.example.com", :times => 1)
+      assert_requested(:get, "http://www.example.com", times: 1)
       assert_requested(:get, "http://www.example.com")
     end
 
     it "should verify that expected http stub occured" do
       http_request(:get, "http://www.example.com/")
-      assert_requested(@stub_http, :times => 1)
+      assert_requested(@stub_http, times: 1)
       assert_requested(@stub_http)
     end
 
     it "should verify that expected https stub occured" do
       http_request(:get, "https://www.example.com/")
       http_request(:get, "https://www.example.com/")
-      assert_requested(@stub_https, :times => 2)
+      assert_requested(@stub_https, times: 2)
     end
 
     it  "should verify that expect request didn't occur" do

data/spec/acceptance/curb/curb_spec.rb

@@ -11,8 +11,8 @@ unless RUBY_PLATFORM =~ /java/
 
     describe "when doing PUTs" do
       it "should stub them" do
-        stub_request(:put, "www.example.com").with(:body => "01234")
-        expect(http_request(:put, "http://www.example.com", :body => "01234").
+        stub_request(:put, "www.example.com").with(body: "01234")
+        expect(http_request(:put, "http://www.example.com", body: "01234").
           status).to eq("200")
       end
     end
@@ -30,9 +30,26 @@ unless RUBY_PLATFORM =~ /java/
         @curl.url = "http://example.com"
       end
 
+      describe 'on_debug' do
+        it "should call on_debug" do
+          stub_request(:any, "example.com").
+            to_return(status: 200, headers: { 'Server' => 'nginx' }, body: { hello: :world }.to_json)
+
+          test = []
+
+          @curl.on_debug do |message, operation|
+            test << "#{operation} -> #{message}"
+          end
+          @curl.headers['Content-Type'] = 'application/json'
+          @curl.http_post({ hello: :world }.to_json)
+
+          expect(test).to_not be_empty
+        end
+      end
+
       it "should call on_success with 2xx response" do
         body = "on_success fired"
-        stub_request(:any, "example.com").to_return(:body => body)
+        stub_request(:any, "example.com").to_return(body: body)
 
         test = nil
         @curl.on_success do |c|
@@ -45,7 +62,7 @@ unless RUBY_PLATFORM =~ /java/
       it "should call on_missing with 4xx response" do
         response_code = 403
         stub_request(:any, "example.com").
-          to_return(:status => [response_code, "None shall pass"])
+          to_return(status: [response_code, "None shall pass"])
 
         test = nil
         @curl.on_missing do |c, code|
@@ -58,7 +75,7 @@ unless RUBY_PLATFORM =~ /java/
       it "should call on_failure with 5xx response" do
         response_code = 599
         stub_request(:any, "example.com").
-          to_return(:status => [response_code, "Server On Fire"])
+          to_return(status: [response_code, "Server On Fire"])
 
         test = nil
         @curl.on_failure do |c, code|
@@ -71,7 +88,7 @@ unless RUBY_PLATFORM =~ /java/
       it "should call on_body when response body is read" do
         body = "on_body fired"
         stub_request(:any, "example.com").
-          to_return(:body => body)
+          to_return(body: body)
 
         test = nil
         @curl.on_body do |data|
@@ -83,8 +100,8 @@ unless RUBY_PLATFORM =~ /java/
 
       it "should call on_body for each chunk with chunked response" do
         stub_request(:any, "example.com").
-          to_return(:body => ["first_chunk", "second_chunk"],
-                    :headers => {"Transfer-Encoding" => "chunked"})
+          to_return(body: ["first_chunk", "second_chunk"],
+                    headers: {"Transfer-Encoding" => "chunked"})
 
         test = []
         @curl.on_body do |data|
@@ -96,7 +113,7 @@ unless RUBY_PLATFORM =~ /java/
 
       it "should call on_header when response headers are read" do
         stub_request(:any, "example.com").
-          to_return(:headers => {:one => 1})
+          to_return(headers: {one: 1})
 
         test = []
         @curl.on_header do |data|
@@ -111,7 +128,7 @@ unless RUBY_PLATFORM =~ /java/
 
       it "should call on_complete when request is complete" do
         body = "on_complete fired"
-        stub_request(:any, "example.com").to_return(:body => body)
+        stub_request(:any, "example.com").to_return(body: body)
 
         test = nil
         @curl.on_complete do |curl|
@@ -122,7 +139,7 @@ unless RUBY_PLATFORM =~ /java/
       end
 
       it "should call on_progress when portion of response body is read" do
-        stub_request(:any, "example.com").to_return(:body => "01234")
+        stub_request(:any, "example.com").to_return(body: "01234")
 
         test = nil
         @curl.on_progress do |*args|
@@ -150,7 +167,7 @@ unless RUBY_PLATFORM =~ /java/
       end
 
       it "should call callbacks in correct order on failed request" do
-        stub_request(:any, "example.com").to_return(:status => [500, ""])
+        stub_request(:any, "example.com").to_return(status: [500, ""])
         order = []
         @curl.on_success {|*args| order << :on_success }
         @curl.on_missing {|*args| order << :on_missing }
@@ -165,7 +182,7 @@ unless RUBY_PLATFORM =~ /java/
       end
 
       it "should call callbacks in correct order on missing request" do
-        stub_request(:any, "example.com").to_return(:status => [403, ""])
+        stub_request(:any, "example.com").to_return(status: [403, ""])
         order = []
         @curl.on_success {|*args| order << :on_success }
         @curl.on_missing {|*args| order << :on_missing }
@@ -191,9 +208,9 @@ unless RUBY_PLATFORM =~ /java/
 
         it 'should be the same as #url even with a location header' do
           stub_request(:any, 'example.com').
-            to_return(:body    => "abc",
-                      :status  => 302,
-                      :headers => { 'Location' => 'http://www.example.com' })
+            to_return(body: "abc",
+                      status: 302,
+                      headers: { 'Location' => 'http://www.example.com' })
 
           @curl.http_get
           expect(@curl.last_effective_url).to eq('http://example.com')
@@ -211,7 +228,7 @@ unless RUBY_PLATFORM =~ /java/
 
         it 'should be the value of the location header when present' do
           stub_request(:any, 'example.com').
-            to_return(:headers => { 'Location' => 'http://www.example.com' })
+            to_return(headers: { 'Location' => 'http://www.example.com' })
           stub_request(:any, 'www.example.com')
 
           @curl.http_get
@@ -220,9 +237,9 @@ unless RUBY_PLATFORM =~ /java/
 
         it 'should work with more than one redirect' do
           stub_request(:any, 'example.com').
-            to_return(:headers => { 'Location' => 'http://www.example.com' })
+            to_return(headers: { 'Location' => 'http://www.example.com' })
           stub_request(:any, 'www.example.com').
-            to_return(:headers => { 'Location' => 'http://blog.example.com' })
+            to_return(headers: { 'Location' => 'http://blog.example.com' })
           stub_request(:any, 'blog.example.com')
 
           @curl.http_get
@@ -231,7 +248,7 @@ unless RUBY_PLATFORM =~ /java/
 
         it 'should maintain the original url' do
           stub_request(:any, 'example.com').
-            to_return(:headers => { 'Location' => 'http://www.example.com' })
+            to_return(headers: { 'Location' => 'http://www.example.com' })
           stub_request(:any, 'www.example.com')
 
           @curl.http_get
@@ -240,10 +257,10 @@ unless RUBY_PLATFORM =~ /java/
 
         it 'should have the redirected-to attrs (body, response code)' do
           stub_request(:any, 'example.com').
-            to_return(:body => 'request A',
-                      :status => 302,
-                      :headers => { 'Location' => 'http://www.example.com' })
-          stub_request(:any, 'www.example.com').to_return(:body => 'request B')
+            to_return(body: 'request A',
+                      status: 302,
+                      headers: { 'Location' => 'http://www.example.com' })
+          stub_request(:any, 'www.example.com').to_return(body: 'request B')
 
           @curl.http_get
           expect(@curl.body_str).to eq('request B')
@@ -252,10 +269,10 @@ unless RUBY_PLATFORM =~ /java/
 
         it 'should follow more than one redirect' do
           stub_request(:any, 'example.com').
-            to_return(:headers => { 'Location' => 'http://www.example.com' })
+            to_return(headers: { 'Location' => 'http://www.example.com' })
           stub_request(:any, 'www.example.com').
-            to_return(:headers => { 'Location' => 'http://blog.example.com' })
-          stub_request(:any, 'blog.example.com').to_return(:body => 'blog post')
+            to_return(headers: { 'Location' => 'http://blog.example.com' })
+          stub_request(:any, 'blog.example.com').to_return(body: 'blog post')
 
           @curl.http_get
           expect(@curl.url).to eq('http://example.com')
@@ -275,9 +292,9 @@ unless RUBY_PLATFORM =~ /java/
           content_type = "application/json"
 
           stub_request(:any, 'example.com').
-            to_return(:body     => "abc",
-                      :status   => 200,
-                      :headers  => { 'Content-Type' => content_type })
+            to_return(body: "abc",
+                      status: 200,
+                      headers: { 'Content-Type' => content_type })
 
           @curl.http_get
           expect(@curl.content_type).to eq(content_type)
@@ -288,8 +305,8 @@ unless RUBY_PLATFORM =~ /java/
         it "returns nil for content_type" do
 
           stub_request(:any, 'example.com').
-            to_return(:body     => "abc",
-                      :status   => 200 )
+            to_return(body: "abc",
+                      status: 200 )
 
           @curl.http_get
           expect(@curl.content_type).to be_nil
@@ -305,9 +322,9 @@ unless RUBY_PLATFORM =~ /java/
 
       it "is true when Transfer-Encoding is 'chunked' and body responds to each" do
         stub_request(:any, 'example.com').
-          to_return(:body     => ["abc", "def"],
-                    :status   => 200,
-                    :headers  => { 'Transfer-Encoding' => 'chunked' })
+          to_return(body: ["abc", "def"],
+                    status: 200,
+                    headers: { 'Transfer-Encoding' => 'chunked' })
 
         @curl.http_get
         expect(@curl).to be_chunked_response
@@ -315,8 +332,8 @@ unless RUBY_PLATFORM =~ /java/
 
       it "is false when Transfer-Encoding is not 'chunked'" do
         stub_request(:any, 'example.com').
-          to_return(:body     => ["abc", "def"],
-                    :status   => 200)
+          to_return(body: ["abc", "def"],
+                    status: 200)
 
         @curl.http_get
         expect(@curl).not_to be_chunked_response
@@ -324,8 +341,8 @@ unless RUBY_PLATFORM =~ /java/
 
       it "is false when Transfer-Encoding is 'chunked' but body does not respond to each" do
         stub_request(:any, 'example.com').
-          to_return(:body     => "abc",
-                    :status   => 200)
+          to_return(body: "abc",
+                    status: 200)
 
         @curl.http_get
         expect(@curl).not_to be_chunked_response
@@ -339,7 +356,7 @@ unless RUBY_PLATFORM =~ /java/
       include CurbSpecHelper::DynamicHttp
 
       it "should work with uppercase arguments" do
-        stub_request(:get, "www.example.com").to_return(:body => "abc")
+        stub_request(:get, "www.example.com").to_return(body: "abc")
 
         c = Curl::Easy.new
         c.url = "http://www.example.com"
@@ -348,7 +365,7 @@ unless RUBY_PLATFORM =~ /java/
       end
 
       it "should alias body to body_str" do
-        stub_request(:get, "www.example.com").to_return(:body => "abc")
+        stub_request(:get, "www.example.com").to_return(body: "abc")
 
         c = Curl::Easy.new
         c.url = "http://www.example.com"
@@ -357,7 +374,7 @@ unless RUBY_PLATFORM =~ /java/
       end
 
       it "supports array headers passed to Curl::Easy" do
-        stub_request(:get, "www.example.com").with(headers: {'X-One' => '1'}).to_return(:body => "abc")
+        stub_request(:get, "www.example.com").with(headers: {'X-One' => '1'}).to_return(body: "abc")
 
         c = Curl::Easy.new
         c.url = "http://www.example.com"
@@ -372,7 +389,7 @@ unless RUBY_PLATFORM =~ /java/
       include CurbSpecHelper::NamedHttp
 
       it "should work with blank arguments for post" do
-        stub_request(:post, "www.example.com").with(:body => "01234")
+        stub_request(:post, "www.example.com").with(body: "01234")
         c = Curl::Easy.new
         c.url = "http://www.example.com"
         c.post_body = "01234"
@@ -381,13 +398,13 @@ unless RUBY_PLATFORM =~ /java/
       end
 
       it "should work with several body arguments for post using the class method" do
-        stub_request(:post, "www.example.com").with(:body => {:user => {:first_name=>'Bartosz', :last_name=>'Blimke'}})
+        stub_request(:post, "www.example.com").with(body: {user: {first_name: 'Bartosz', last_name: 'Blimke'}})
         c = Curl::Easy.http_post "http://www.example.com", 'user[first_name]=Bartosz', 'user[last_name]=Blimke'
         expect(c.response_code).to eq(200)
       end
 
       it "should work with blank arguments for put" do
-        stub_request(:put, "www.example.com").with(:body => "01234")
+        stub_request(:put, "www.example.com").with(body: "01234")
         c = Curl::Easy.new
         c.url = "http://www.example.com"
         c.put_data = "01234"
@@ -396,9 +413,9 @@ unless RUBY_PLATFORM =~ /java/
       end
 
       it "should work with multiple arguments for post" do
-        data = { :name => "john", :address => "111 example ave" }
+        data = { name: "john", address: "111 example ave" }
 
-        stub_request(:post, "www.example.com").with(:body => data)
+        stub_request(:post, "www.example.com").with(body: data)
         c = Curl::Easy.new
         c.url = "http://www.example.com"
         c.http_post Curl::PostField.content('name', data[:name]),  Curl::PostField.content('address', data[:address])

data/spec/acceptance/curb/curb_spec_helper.rb

@@ -21,10 +21,10 @@ module CurbSpecHelper
     end
 
     OpenStruct.new(
-      :body => curl.body_str,
-      :headers => WebMock::Util::Headers.normalize_headers(response_headers),
-      :status => curl.response_code.to_s,
-      :message => status
+      body: curl.body_str,
+      headers: WebMock::Util::Headers.normalize_headers(response_headers),
+      status: curl.response_code.to_s,
+      message: status
     )
   end
 

data/spec/acceptance/em_http_request/em_http_request_spec.rb

@@ -13,7 +13,7 @@ unless RUBY_PLATFORM =~ /java/
 
     #functionality only supported for em-http-request 1.x
     if defined?(EventMachine::HttpConnection)
-      context 'when a real request is made and redirects are followed', :net_connect => true do
+      context 'when a real request is made and redirects are followed', net_connect: true do
         before { WebMock.allow_net_connect! }
 
         # This url redirects to the https URL.
@@ -22,7 +22,7 @@ unless RUBY_PLATFORM =~ /java/
 
         def make_request
           EM.run do
-            request = EM::HttpRequest.new(http_url).get(:redirects => 1)
+            request = EM::HttpRequest.new(http_url).get(redirects: 1)
             request.callback { EM.stop }
           end
         end
@@ -49,7 +49,7 @@ unless RUBY_PLATFORM =~ /java/
       describe "with middleware" do
 
         it "should work with request middleware" do
-          stub_request(:get, "www.example.com").with(:body => 'bar')
+          stub_request(:get, "www.example.com").with(body: 'bar')
 
           middleware = Class.new do
             def request(client, head, body)
@@ -62,10 +62,10 @@ unless RUBY_PLATFORM =~ /java/
 
             conn.use middleware
 
-            http = conn.get(:body => 'foo')
+            http = conn.get(body: 'foo')
 
             http.callback do
-              expect(WebMock).to have_requested(:get, "www.example.com").with(:body => 'bar')
+              expect(WebMock).to have_requested(:get, "www.example.com").with(body: 'bar')
               EM.stop
             end
           end
@@ -80,7 +80,7 @@ unless RUBY_PLATFORM =~ /java/
         end
 
         it "should work with response middleware" do
-          stub_request(:get, "www.example.com").to_return(:body => 'foo')
+          stub_request(:get, "www.example.com").to_return(body: 'foo')
 
           EM.run do
             conn = EventMachine::HttpRequest.new('http://www.example.com/')
@@ -116,13 +116,13 @@ unless RUBY_PLATFORM =~ /java/
           end
         end
 
-        context 'making a real request', :net_connect => true do
+        context 'making a real request', net_connect: true do
           before { WebMock.allow_net_connect! }
           include_examples "em-http-request middleware/after_request hook integration"
         end
 
         context 'when the request is stubbed' do
-          before { stub_request(:get, webmock_server_url).to_return(:body => 'hello world') }
+          before { stub_request(:get, webmock_server_url).to_return(body: 'hello world') }
           include_examples "em-http-request middleware/after_request hook integration"
         end
       end
@@ -160,11 +160,11 @@ unless RUBY_PLATFORM =~ /java/
           end
 
           it "should work" do
-            stub_request(:post, /.*.testserver.com*/).to_return(:status => 200, :body => 'ok')
+            stub_request(:post, /.*.testserver.com*/).to_return(status: 200, body: 'ok')
             expect {
               EM.run do
                 fiber = Fiber.new do
-                  EM::HttpRequest.new("http://www.testserver.com").post :body => "foo=bar&baz=bang", :timeout => 60
+                  EM::HttpRequest.new("http://www.testserver.com").post body: "foo=bar&baz=bang", timeout: 60
                   EM.stop
                 end
                 fiber.resume
@@ -187,7 +187,7 @@ unless RUBY_PLATFORM =~ /java/
     end
 
     it "should work with streaming" do
-      stub_request(:get, "www.example.com").to_return(:body => "abc")
+      stub_request(:get, "www.example.com").to_return(body: "abc")
       response = ""
       EM.run {
         http = EventMachine::HttpRequest.new('http://www.example.com/').get
@@ -197,41 +197,41 @@ unless RUBY_PLATFORM =~ /java/
     end
 
     it "should work with responses that use chunked transfer encoding" do
-      stub_request(:get, "www.example.com").to_return(:body => "abc", :headers => { 'Transfer-Encoding' => 'chunked' })
+      stub_request(:get, "www.example.com").to_return(body: "abc", headers: { 'Transfer-Encoding' => 'chunked' })
       expect(http_request(:get, "http://www.example.com").body).to eq("abc")
     end
 
     it "should work with optional query params" do
-      stub_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(:body => "abc")
-      expect(http_request(:get, "http://www.example.com/?x=3", :query => {"a" => ["b", "c"]}).body).to eq("abc")
+      stub_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(body: "abc")
+      expect(http_request(:get, "http://www.example.com/?x=3", query: {"a" => ["b", "c"]}).body).to eq("abc")
     end
 
     it "should work with optional query params declared as string" do
-      stub_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(:body => "abc")
-      expect(http_request(:get, "http://www.example.com/?x=3", :query => "a[]=b&a[]=c").body).to eq("abc")
+      stub_request(:get, "www.example.com/?x=3&a[]=b&a[]=c").to_return(body: "abc")
+      expect(http_request(:get, "http://www.example.com/?x=3", query: "a[]=b&a[]=c").body).to eq("abc")
     end
 
     it "should work when the body is passed as a Hash" do
-      stub_request(:post, "www.example.com").with(:body => {:a => "1", :b => "2"}).to_return(:body => "ok")
-      expect(http_request(:post, "http://www.example.com", :body => {:a => "1", :b => "2"}).body).to eq("ok")
+      stub_request(:post, "www.example.com").with(body: {a: "1", b: "2"}).to_return(body: "ok")
+      expect(http_request(:post, "http://www.example.com", body: {a: "1", b: "2"}).body).to eq("ok")
     end
 
     if defined?(EventMachine::HttpConnection)
       it "should work when a file is passed as body" do
-        stub_request(:post, "www.example.com").with(:body => File.read(__FILE__)).to_return(:body => "ok")
-        expect(http_request(:post, "http://www.example.com", :file => __FILE__).body).to eq("ok")
+        stub_request(:post, "www.example.com").with(body: File.read(__FILE__)).to_return(body: "ok")
+        expect(http_request(:post, "http://www.example.com", file: __FILE__).body).to eq("ok")
       end
     end
 
     it "should work with UTF-8 strings" do
       body = "Привет, Мир!"
-      stub_request(:post, "www.example.com").to_return(:body => body)
+      stub_request(:post, "www.example.com").to_return(body: body)
       expect(http_request(:post, "http://www.example.com").body.bytesize).to eq(body.bytesize)
     end
 
     it "should work with multiple requests to the same connection" do
-      stub_request(:get, "www.example.com/foo").to_return(:body => "bar")
-      stub_request(:get, "www.example.com/baz").to_return(:body => "wombat")
+      stub_request(:get, "www.example.com/foo").to_return(body: "bar")
+      stub_request(:get, "www.example.com/baz").to_return(body: "wombat")
       err1  = nil
       err2  = nil
       body1 = nil
@@ -240,7 +240,7 @@ unless RUBY_PLATFORM =~ /java/
 
       EM.run do
         conn = EM::HttpRequest.new("http://www.example.com")
-        conn.get(:path => "/foo").callback do |resp|
+        conn.get(path: "/foo").callback do |resp|
           body1 = resp.response
           i += 1; EM.stop if i == 2
         end.errback do |resp|
@@ -248,7 +248,7 @@ unless RUBY_PLATFORM =~ /java/
           i += 1; EM.stop if i == 2
         end
 
-        conn.get(:path => "/baz").callback do |resp|
+        conn.get(path: "/baz").callback do |resp|
           body2 = resp.response
           i += 1; EM.stop if i == 2
         end.errback do |resp|
@@ -264,17 +264,17 @@ unless RUBY_PLATFORM =~ /java/
     end
 
     it "should work with multiple requests to the same connection when the first request times out" do
-      stub_request(:get, "www.example.com/foo").to_timeout.then.to_return(:status => 200, :body => "wombat")
+      stub_request(:get, "www.example.com/foo").to_timeout.then.to_return(status: 200, body: "wombat")
       err  = nil
       body = nil
 
       EM.run do
         conn = EM::HttpRequest.new("http://www.example.com")
-        conn.get(:path => "/foo").callback do |resp|
+        conn.get(path: "/foo").callback do |resp|
           err = :success_from_timeout
           EM.stop
         end.errback do |resp|
-          conn.get(:path => "/foo").callback do |retry_resp|
+          conn.get(path: "/foo").callback do |retry_resp|
             expect(retry_resp.response_header.status).to eq(200)
             body = retry_resp.response
             EM.stop
@@ -319,7 +319,7 @@ unless RUBY_PLATFORM =~ /java/
 
       context "with a query" do
         let(:uri) { "http://www.example.com/?a=1&b=2" }
-        subject { client("http://www.example.com/?a=1", :query => { 'b' => 2 }) }
+        subject { client("http://www.example.com/?a=1", query: { 'b' => 2 }) }
 
         it "#request_signature doesn't mutate the original uri" do
           expect(subject.uri).to eq(Addressable::URI.parse("http://www.example.com/?a=1"))
@@ -333,9 +333,9 @@ unless RUBY_PLATFORM =~ /java/
         before(:each) do
           stub_request(:get, "http://example.org/").
           to_return(
-            :status => 200,
-            :body => "",
-            :headers => { 'Set-Cookie' => cookie_string }
+            status: 200,
+            body: "",
+            headers: { 'Set-Cookie' => cookie_string }
           )
         end