webmock 2.0.3 → 2.1.0

data/spec/acceptance/em_http_request/em_http_request_spec_helper.rb

@@ -18,11 +18,11 @@ module EMHttpRequestSpecHelper
     EventMachine.run {
       request = EventMachine::HttpRequest.new("#{uri.normalize.to_s}")
       http = request.send(method, {
-        :timeout => 30,
-        :body => options[:body],
-        :file => options[:file],
-        :query => options[:query],
-        :head => head
+        timeout: 30,
+        body: options[:body],
+        file: options[:file],
+        query: options[:query],
+        head: head
       }, &block)
       http.errback {
         error_set = true
@@ -35,10 +35,10 @@ module EMHttpRequestSpecHelper
       }
       http.callback {
         response = OpenStruct.new({
-          :body => http.response,
-          :headers => WebMock::Util::Headers.normalize_headers(extract_response_headers(http)),
-          :message => http.response_header.http_reason,
-          :status => http.response_header.status.to_s
+          body: http.response,
+          headers: WebMock::Util::Headers.normalize_headers(extract_response_headers(http)),
+          message: http.response_header.http_reason,
+          status: http.response_header.status.to_s
         })
         EventMachine.stop
       }

data/spec/acceptance/excon/excon_spec.rb

@@ -7,40 +7,40 @@ describe "Excon" do
   include_context "with WebMock", :no_status_message, :no_url_auth
 
   it 'should allow Excon requests to use query hash paramters' do
-    stub_request(:get, "http://example.com/resource/?a=1&b=2").to_return(:body => "abc")
-    expect(Excon.new('http://example.com').get(:path => "resource/", :query => {:a => 1, :b => 2}).body).to eq("abc")
+    stub_request(:get, "http://example.com/resource/?a=1&b=2").to_return(body: "abc")
+    expect(Excon.new('http://example.com').get(path: "resource/", query: {a: 1, b: 2}).body).to eq("abc")
   end
 
   it 'should support Excon :expects options' do
-    stub_request(:get, "http://example.com/").to_return(:body => 'a')
-    expect { Excon.new('http://example.com').get(:expects => 204) }.to raise_error(Excon::Errors::OK)
+    stub_request(:get, "http://example.com/").to_return(body: 'a')
+    expect { Excon.new('http://example.com').get(expects: 204) }.to raise_error(Excon::Errors::OK)
   end
 
   context "with response_block" do
-    it "should support excon response_block for real requests", :net_connect => true do
+    it "should support excon response_block for real requests", net_connect: true do
       a = []
       WebMock.allow_net_connect!
-      r = Excon.new('http://httpstat.us/200').get(:response_block => lambda {|e, remaining, total| a << e}, :chunk_size => 1)
+      r = Excon.new('http://httpstat.us/200').get(response_block: lambda {|e, remaining, total| a << e}, chunk_size: 1)
       expect(a).to eq(["2", "0", "0", " ", "O", "K"])
       expect(r.body).to eq("")
     end
 
     it "should support excon response_block" do
       a = []
-      stub_request(:get, "http://example.com/").to_return(:body => "abc")
-      r = Excon.new('http://example.com').get(:response_block => lambda {|e, remaining, total| a << e}, :chunk_size => 1)
+      stub_request(:get, "http://example.com/").to_return(body: "abc")
+      r = Excon.new('http://example.com').get(response_block: lambda {|e, remaining, total| a << e}, chunk_size: 1)
       expect(a).to eq(['a', 'b', 'c'])
       expect(r.body).to eq("")
     end
 
-    it "should invoke callbacks with response body even if a real request is made", :net_connect => true do
+    it "should invoke callbacks with response body even if a real request is made", net_connect: true do
       a = []
       WebMock.allow_net_connect!
       response = nil
       WebMock.after_request { |_, res|
         response = res
       }
-      r = Excon.new('http://httpstat.us/200').get(:response_block => lambda {|e, remaining, total| a << e}, :chunk_size => 1)
+      r = Excon.new('http://httpstat.us/200').get(response_block: lambda {|e, remaining, total| a << e}, chunk_size: 1)
       expect(response.body).to eq("200 OK")
       expect(a).to eq(["2", "0", "0", " ", "O", "K"])
       expect(r.body).to eq("")
@@ -51,14 +51,14 @@ describe "Excon" do
   let(:file_contents) { File.read(__FILE__) }
 
   it 'handles file uploads correctly' do
-    stub_request(:put, "http://example.com/upload").with(:body => file_contents)
+    stub_request(:put, "http://example.com/upload").with(body: file_contents)
 
     yielded_request_body = nil
     WebMock.after_request do |req, res|
       yielded_request_body = req.body
     end
 
-    Excon.new("http://example.com").put(:path => "upload", :body => file)
+    Excon.new("http://example.com").put(path: "upload", body: file)
 
     expect(yielded_request_body).to eq(file_contents)
   end
@@ -66,8 +66,8 @@ describe "Excon" do
   describe '.request_params_from' do
 
     it 'rejects invalid request keys' do
-      request_params = WebMock::HttpLibAdapters::ExconAdapter.request_params_from(:body => :keep, :fake => :reject)
-      expect(request_params).to eq(:body => :keep)
+      request_params = WebMock::HttpLibAdapters::ExconAdapter.request_params_from(body: :keep, fake: :reject)
+      expect(request_params).to eq(body: :keep)
     end
 
   end

data/spec/acceptance/excon/excon_spec_helper.rb

@@ -14,10 +14,10 @@ module ExconSpecHelper
     end
 
     if Gem::Version.new(Excon::VERSION) < Gem::Version.new("0.29.0")
-      options  = options.merge(:method => method, :nonblock => false) # Dup and merge
+      options  = options.merge(method: method, nonblock: false) # Dup and merge
       response = Excon.new(uri, excon_options).request(options, &block)
     else
-      options  = options.merge(:method => method) # Dup and merge
+      options  = options.merge(method: method) # Dup and merge
       response = Excon.new(uri, excon_options.merge(nonblock: false)).request(options, &block)
     end
 
@@ -28,10 +28,10 @@ module ExconSpecHelper
     end
 
     OpenStruct.new \
-      :body => response.body,
-      :headers => headers,
-      :status  => response.status.to_s,
-      :message => ""
+      body: response.body,
+      headers: headers,
+      status: response.status.to_s,
+      message: ""
   end
 
   def client_timeout_exception_class

data/spec/acceptance/http_rb/http_rb_spec.rb

@@ -36,7 +36,7 @@ describe "HTTP.rb" do
   end
 
   context "following redirects" do
-    let(:options)  { { :follow => true } }
+    let(:options)  { { follow: true } }
     let(:response) { http_request(:get, "http://example.com", options) }
     let(:headers)  { response.headers }
 

data/spec/acceptance/http_rb/http_rb_spec_helper.rb

@@ -11,10 +11,10 @@ module HttpRbSpecHelper
     response = chain.request(method, normalize_uri(uri), options)
 
     OpenStruct.new({
-      :body       => response.body.to_s,
-      :headers    => normalize_headers(response.headers.to_h),
-      :status     => response.code.to_s,
-      :message    => response.reason
+      body: response.body.to_s,
+      headers: normalize_headers(response.headers.to_h),
+      status: response.code.to_s,
+      message: response.reason
     })
   end
 
@@ -43,9 +43,9 @@ module HttpRbSpecHelper
 
   def stub_simple_request(host, status = 200, headers = {}, body = nil)
     stub_request(:any, host).to_return({
-      :status   => status,
-      :headers  => headers.merge({ "Host" => host }),
-      :body     => body
+      status: status,
+      headers: headers.merge({ "Host" => host }),
+      body: body
     })
   end
 end

data/spec/acceptance/httpclient/httpclient_spec.rb

@@ -15,15 +15,15 @@ describe "HTTPClient" do
   include_examples "with WebMock"
 
   it "should raise a clearly readable error if request with multipart body is sent" do
-    stub_request(:post, 'www.example.com').with(:body => {:type => 'image'})
+    stub_request(:post, 'www.example.com').with(body: {type: 'image'})
 
     expect {
-      HTTPClient.new.post_content('www.example.com', :type => 'image', :file => File.new('spec/fixtures/test.txt'))
+      HTTPClient.new.post_content('www.example.com', type: 'image', file: File.new('spec/fixtures/test.txt'))
     }.to raise_error(ArgumentError, "WebMock does not support matching body for multipart/form-data requests yet :(")
   end
 
   it "should yield block on response if block provided" do
-    stub_request(:get, "www.example.com").to_return(:body => "abc")
+    stub_request(:get, "www.example.com").to_return(body: "abc")
     response_body = ""
     http_request(:get, "http://www.example.com/") do |body|
       response_body = body
@@ -32,10 +32,10 @@ describe "HTTPClient" do
   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
 
   describe "when using async requests" do
@@ -47,7 +47,7 @@ describe "HTTPClient" do
   end
 
   it "should work with get_content" do
-    stub_request(:get, 'www.example.com').to_return(:status => 200, :body => 'test', :headers => {})
+    stub_request(:get, 'www.example.com').to_return(status: 200, body: 'test', headers: {})
     str = ''
     HTTPClient.get_content('www.example.com') do |content|
       str << content
@@ -57,9 +57,9 @@ describe "HTTPClient" do
 
   it "should work via JSONClient subclass" do
     stub_request(:get, 'www.example.com').to_return(
-      :status => 200,
-      :body => '{"test": "foo"}',
-      :headers => {'Content-Type' => 'application/json'}
+      status: 200,
+      body: '{"test": "foo"}',
+      headers: {'Content-Type' => 'application/json'}
     )
     content = JSONClient.get('www.example.com').content
     expect(content).to eq("test" => "foo")
@@ -79,7 +79,7 @@ describe "HTTPClient" do
       }
     ]}
 
-    let(:make_request) {HTTPClient.new.post("http://www.example.com", :body => body, :header => header)}
+    let(:make_request) {HTTPClient.new.post("http://www.example.com", body: body, header: header)}
 
     before do
       stub_request(:post, "www.example.com")
@@ -105,7 +105,7 @@ describe "HTTPClient" do
     before do
       @client = HTTPClient.new
       @client.request_filter << Filter.new
-      stub_request(:get, 'www.example.com').with(:headers => {'Authorization' => 'Bearer 0123456789'})
+      stub_request(:get, 'www.example.com').with(headers: {'Authorization' => 'Bearer 0123456789'})
     end
 
     it "supports request filters" do
@@ -131,13 +131,13 @@ describe "HTTPClient" do
         nil # to let the request be made for real
       end
 
-      http_request(:get, webmock_server_url, :client => client, :headers => { "Cookie" => "bar=; foo=" })
+      http_request(:get, webmock_server_url, client: client, headers: { "Cookie" => "bar=; foo=" })
 
       if defined? HTTP::CookieJar
-        http_request(:get, webmock_server_url, :client => client, :headers => { "Cookie" => "bar=; foo=" })
+        http_request(:get, webmock_server_url, client: client, headers: { "Cookie" => "bar=; foo=" })
       else
         # If http-cookie is not present, then the cookie headers will saved between requests
-        http_request(:get, webmock_server_url, :client => client)
+        http_request(:get, webmock_server_url, client: client)
       end
 
       expect(request_signatures.size).to eq(2)
@@ -149,8 +149,8 @@ describe "HTTPClient" do
   context 'session headers' do
     it "client sends a User-Agent header when given an agent_name explicitly to the client" do
       user_agent = "Client/0.1"
-      stub_request(:get, "www.example.com").with(:headers => { 'User-agent' => "#{user_agent} #{HTTPClient::LIB_NAME}" })
-      HTTPClient.new(:agent_name => user_agent).get("www.example.com")
+      stub_request(:get, "www.example.com").with(headers: { 'User-agent' => "#{user_agent} #{HTTPClient::LIB_NAME}" })
+      HTTPClient.new(agent_name: user_agent).get("www.example.com")
     end
 
     it "client sends the Accept, User-Agent, and Date by default" do
@@ -165,7 +165,7 @@ describe "HTTPClient" do
 
     it "explicitly defined headers take precedence over session defaults" do
       headers = { 'Accept'  => 'foo/bar', 'User-Agent' => 'custom', 'Date' => 'today' }
-      stub_request(:get, "www.example.com").with(:headers => headers)
+      stub_request(:get, "www.example.com").with(headers: headers)
       HTTPClient.new.get("www.example.com", nil, headers)
     end
   end
@@ -181,7 +181,7 @@ describe "HTTPClient" do
   context 'httpclient streams response' do
     before do
       WebMock.allow_net_connect!
-      WebMock.after_request(:except => [:other_lib])  do |_, response|
+      WebMock.after_request(except: [:other_lib])  do |_, response|
         @response = response
       end
     end
@@ -197,9 +197,9 @@ describe "HTTPClient" do
 
   context 'credentials' do
     it 'are detected when manually specifying Authorization header' do
-      stub_request(:get, 'username:password@www.example.com').to_return(:status => 200)
+      stub_request(:get, 'username:password@www.example.com').to_return(status: 200)
       headers = {'Authorization' => 'Basic dXNlcm5hbWU6cGFzc3dvcmQ='}
-      expect(http_request(:get, 'http://www.example.com/', {:headers => headers}).status).to eql('200')
+      expect(http_request(:get, 'http://www.example.com/', {headers: headers}).status).to eql('200')
     end
   end
 end

data/spec/acceptance/httpclient/httpclient_spec_helper.rb

@@ -12,7 +12,7 @@ module HTTPClientSpecHelper
       c.set_basic_auth(nil, options[:basic_auth][0], options[:basic_auth][1])
     end
     params = [method, uri.normalize.to_s,
-      WebMock::Util::QueryMapper.query_to_values(uri.query, :notation => WebMock::Config.instance.query_values_notation), options[:body], options[:headers] || {}]
+      WebMock::Util::QueryMapper.query_to_values(uri.query, notation: WebMock::Config.instance.query_values_notation), options[:body], options[:headers] || {}]
     if HTTPClientSpecHelper.async_mode
       connection = c.request_async(*params)
       connection.join
@@ -22,10 +22,10 @@ module HTTPClientSpecHelper
     end
     headers = merge_headers(response)
     OpenStruct.new({
-      :body => HTTPClientSpecHelper.async_mode ? response.content.read : response.content,
-      :headers => headers,
-      :status => response.code.to_s,
-      :message => response.reason
+      body: HTTPClientSpecHelper.async_mode ? response.content.read : response.content,
+      headers: headers,
+      status: response.code.to_s,
+      message: response.reason
     })
   end
 

data/spec/acceptance/manticore/manticore_spec.rb

@@ -11,43 +11,43 @@ if RUBY_PLATFORM =~ /java/
 
     context "calling http methods on Manticore directly using Manticore's facade" do
       it "handles GET" do
-        stub_request(:get, "http://example-foo.com").to_return(:status => 301)
+        stub_request(:get, "http://example-foo.com").to_return(status: 301)
         response = Manticore.get("http://example-foo.com")
         expect(response.code).to eq(301)
       end
 
       it "handles POST" do
-        stub_request(:post, "http://example-foo.com").to_return(:status => 201)
-        response = Manticore.post("http://example-foo.com", {:hello => "world"})
+        stub_request(:post, "http://example-foo.com").to_return(status: 201)
+        response = Manticore.post("http://example-foo.com", {hello: "world"})
         expect(response.code).to eq(201)
       end
 
       it "handles PUT" do
-        stub_request(:put, "http://example-foo.com").to_return(:status => 409)
-        response = Manticore.put("http://example-foo.com", {:hello => "world"})
+        stub_request(:put, "http://example-foo.com").to_return(status: 409)
+        response = Manticore.put("http://example-foo.com", {hello: "world"})
         expect(response.code).to eq(409)
       end
 
       it "handles PATCH" do
-        stub_request(:patch, "http://example-foo.com").to_return(:status => 409)
-        response = Manticore.patch("http://example-foo.com", {:hello => "world"})
+        stub_request(:patch, "http://example-foo.com").to_return(status: 409)
+        response = Manticore.patch("http://example-foo.com", {hello: "world"})
         expect(response.code).to eq(409)
       end
 
       it "handles DELETE" do
-        stub_request(:delete, "http://example-foo.com").to_return(:status => 204)
-        response = Manticore.delete("http://example-foo.com", {:id => 1})
+        stub_request(:delete, "http://example-foo.com").to_return(status: 204)
+        response = Manticore.delete("http://example-foo.com", {id: 1})
         expect(response.code).to eq(204)
       end
 
       it "handles OPTIONS" do
-        stub_request(:options, "http://example-foo.com").to_return(:status => 200)
+        stub_request(:options, "http://example-foo.com").to_return(status: 200)
         response = Manticore.options("http://example-foo.com")
         expect(response.code).to eq(200)
       end
 
       it "handles HEAD" do
-        stub_request(:head, "http://example-foo.com").to_return(:status => 204)
+        stub_request(:head, "http://example-foo.com").to_return(status: 204)
         response = Manticore.head("http://example-foo.com")
         expect(response.code).to eq(204)
       end

data/spec/acceptance/manticore/manticore_spec_helper.rb

@@ -8,9 +8,9 @@ module ManticoreSpecHelper
 
     response = client.http(method, uri, options)
     OpenStruct.new({
-      :body => response.body || '',
-      :headers => WebMock::Util::Headers.normalize_headers(join_array_values(response.headers)),
-      :status => response.code.to_s
+      body: response.body || '',
+      headers: WebMock::Util::Headers.normalize_headers(join_array_values(response.headers)),
+      status: response.code.to_s
     })
   end
 

data/spec/acceptance/net_http/net_http_shared.rb

@@ -1,17 +1,17 @@
 shared_examples_for "Net::HTTP" do
-  describe "when making real requests", :net_connect => true do
+  describe "when making real requests", net_connect: true do
     let(:port){ WebMockServer.instance.port }
 
     before(:each) do
       @http = Net::HTTP.new("localhost", port)
     end
 
-    it "should return a Net::ReadAdapter from response.body when a real request is made with a block and #read_body", :net_connect => true do
+    it "should return a Net::ReadAdapter from response.body when a real request is made with a block and #read_body", net_connect: true do
       response = Net::HTTP.new("localhost", port).request_get('/') { |r| r.read_body { } }
       expect(response.body).to be_a(Net::ReadAdapter)
     end
 
-    it "should handle requests with block passed to read_body", :net_connect => true do
+    it "should handle requests with block passed to read_body", net_connect: true do
       body = ""
       req = Net::HTTP::Get.new("/")
       Net::HTTP.start("localhost", port) do |http|
@@ -24,7 +24,7 @@ shared_examples_for "Net::HTTP" do
       expect(body).to match(/hello world/)
     end
 
-    it "should connect only once when connected on start", :net_connect => true do
+    it "should connect only once when connected on start", net_connect: true do
       @http = Net::HTTP.new('localhost', port)
       socket_id_before_request = socket_id_after_request = nil
       @http.start {|conn|

data/spec/acceptance/net_http/net_http_spec.rb

@@ -102,13 +102,13 @@ describe "Net:HTTP" do
   end
 
   it "should work with block provided" do
-    stub_http_request(:get, "www.example.com").to_return(:body => "abc"*100000)
+    stub_http_request(:get, "www.example.com").to_return(body: "abc"*100000)
     expect(Net::HTTP.start("www.example.com") { |query| query.get("/") }.body).to eq("abc"*100000)
   end
 
   it "should handle requests with raw binary data" do
     body = "\x14\x00\x00\x00\x70\x69\x6e\x67\x00\x00"
-    stub_http_request(:post, "www.example.com").with(:body => body).to_return(:body => "abc")
+    stub_http_request(:post, "www.example.com").with(body: body).to_return(body: "abc")
     req = Net::HTTP::Post.new("/")
     req.body = body
     req.content_type = "application/octet-stream"
@@ -128,7 +128,7 @@ describe "Net:HTTP" do
       request[:InvalidHeaderSinceItsASymbol] = "this will not be valid"
     else
       request.instance_eval do
-        @header = request.to_hash.merge({:InvalidHeaderSinceItsASymbol => "this will not be valid"})
+        @header = request.to_hash.merge({InvalidHeaderSinceItsASymbol: "this will not be valid"})
       end
     end
 
@@ -145,13 +145,13 @@ describe "Net:HTTP" do
   end
 
   it "should handle multiple values for the same response header" do
-    stub_http_request(:get, "www.example.com").to_return(:headers => { 'Set-Cookie' => ['foo=bar', 'bar=bazz'] })
+    stub_http_request(:get, "www.example.com").to_return(headers: { 'Set-Cookie' => ['foo=bar', 'bar=bazz'] })
     response = Net::HTTP.get_response(URI.parse("http://www.example.com/"))
     expect(response.get_fields('Set-Cookie')).to eq(['bar=bazz', 'foo=bar'])
   end
 
   it "should yield block on response" do
-    stub_http_request(:get, "www.example.com").to_return(:body => "abc")
+    stub_http_request(:get, "www.example.com").to_return(body: "abc")
     response_body = ""
     http_request(:get, "http://www.example.com/") do |response|
       response_body = response.body
@@ -160,21 +160,21 @@ describe "Net:HTTP" do
   end
 
   it "should handle Net::HTTP::Post#body" do
-    stub_http_request(:post, "www.example.com").with(:body => "my_params").to_return(:body => "abc")
+    stub_http_request(:post, "www.example.com").with(body: "my_params").to_return(body: "abc")
     req = Net::HTTP::Post.new("/")
     req.body = "my_params"
     expect(Net::HTTP.start("www.example.com") { |http| http.request(req)}.body).to eq("abc")
   end
 
   it "should handle Net::HTTP::Post#body_stream" do
-    stub_http_request(:post, "www.example.com").with(:body => "my_params").to_return(:body => "abc")
+    stub_http_request(:post, "www.example.com").with(body: "my_params").to_return(body: "abc")
     req = Net::HTTP::Post.new("/")
     req.body_stream = StringIO.new("my_params")
     expect(Net::HTTP.start("www.example.com") { |http| http.request(req)}.body).to eq("abc")
   end
 
   it "should behave like Net::HTTP and raise error if both request body and body argument are set" do
-    stub_http_request(:post, "www.example.com").with(:body => "my_params").to_return(:body => "abc")
+    stub_http_request(:post, "www.example.com").with(body: "my_params").to_return(body: "abc")
     req = Net::HTTP::Post.new("/")
     req.body = "my_params"
     expect {
@@ -183,12 +183,12 @@ describe "Net:HTTP" do
   end
 
   it "should return a Net::ReadAdapter from response.body when a stubbed request is made with a block and #read_body" do
-    WebMock.stub_request(:get, 'http://example.com/').to_return(:body => "the body")
+    WebMock.stub_request(:get, 'http://example.com/').to_return(body: "the body")
     response = Net::HTTP.new('example.com', 80).request_get('/') { |r| r.read_body { } }
     expect(response.body).to be_a(Net::ReadAdapter)
   end
 
-  it "should have request 1 time executed in registry after 1 real request", :net_connect => true do
+  it "should have request 1 time executed in registry after 1 real request", net_connect: true do
     WebMock.allow_net_connect!
     http = Net::HTTP.new('localhost', port)
     http.get('/') {}
@@ -197,7 +197,7 @@ describe "Net:HTTP" do
   end
 
   it "should work with Addressable::URI passed to Net::HTTP.get_response" do
-    stub_request(:get, 'http://www.example.com/hello?a=1').to_return(:body => "abc")
+    stub_request(:get, 'http://www.example.com/hello?a=1').to_return(body: "abc")
     expect(Net::HTTP.get_response(Addressable::URI.parse('http://www.example.com/hello?a=1')).body).to eq("abc")
   end
 
@@ -209,15 +209,15 @@ describe "Net:HTTP" do
     end
 
     describe "when net http is allowed" do
-      it "should not connect to the server until the request", :net_connect => true do
+      it "should not connect to the server until the request", net_connect: true do
         WebMock.allow_net_connect!
         @http.start {|conn|
           expect(conn.peer_cert).to be_nil
         }
       end
 
-      it "should connect to the server on start", :net_connect => true do
-        WebMock.allow_net_connect!(:net_http_connect_on_start => true)
+      it "should connect to the server on start", net_connect: true do
+        WebMock.allow_net_connect!(net_http_connect_on_start: true)
         @http.start {|conn|
           cert = OpenSSL::X509::Certificate.new conn.peer_cert
           expect(cert).to be_a(OpenSSL::X509::Certificate)
@@ -227,28 +227,28 @@ describe "Net:HTTP" do
     end
 
     describe "when net http is disabled and allowed only for some hosts" do
-      it "should not connect to the server until the request", :net_connect => true do
-        WebMock.disable_net_connect!(:allow => "www.google.com")
+      it "should not connect to the server until the request", net_connect: true do
+        WebMock.disable_net_connect!(allow: "www.google.com")
         @http.start {|conn|
           expect(conn.peer_cert).to be_nil
         }
       end
 
-      it "should connect to the server on start", :net_connect => true do
-        WebMock.disable_net_connect!(:allow => "www.google.com", :net_http_connect_on_start => true)
+      it "should connect to the server on start", net_connect: true do
+        WebMock.disable_net_connect!(allow: "www.google.com", net_http_connect_on_start: true)
         @http.start {|conn|
           cert = OpenSSL::X509::Certificate.new conn.peer_cert
           expect(cert).to be_a(OpenSSL::X509::Certificate)
         }
       end
 
-      it "should connect to the server if the URI matches an regex", :net_connect => true do
-        WebMock.disable_net_connect!(:allow => /google.com/)
+      it "should connect to the server if the URI matches an regex", net_connect: true do
+        WebMock.disable_net_connect!(allow: /google.com/)
         Net::HTTP.get('www.google.com','/')
       end
 
-      it "should connect to the server if the URI matches any regex the array", :net_connect => true do
-        WebMock.disable_net_connect!(:allow => [/google.com/, /yahoo.com/])
+      it "should connect to the server if the URI matches any regex the array", net_connect: true do
+        WebMock.disable_net_connect!(allow: [/google.com/, /yahoo.com/])
         Net::HTTP.get('www.google.com','/')
       end
 
@@ -258,19 +258,19 @@ describe "Net:HTTP" do
 
   describe "when net_http_connect_on_start is true" do
     before(:each) do
-      WebMock.allow_net_connect!(:net_http_connect_on_start => true)
+      WebMock.allow_net_connect!(net_http_connect_on_start: true)
     end
     it_should_behave_like "Net::HTTP"
   end
 
   describe "when net_http_connect_on_start is false" do
     before(:each) do
-      WebMock.allow_net_connect!(:net_http_connect_on_start => false)
+      WebMock.allow_net_connect!(net_http_connect_on_start: false)
     end
     it_should_behave_like "Net::HTTP"
   end
 
-  describe 'after_request callback support', :net_connect => true do
+  describe 'after_request callback support', net_connect: true do
     let(:expected_body_regex) { /hello world/ }
 
     before(:each) do