webmock 2.0.3 → 2.1.0

data/spec/acceptance/typhoeus/typhoeus_hydra_spec.rb

@@ -22,7 +22,7 @@ unless RUBY_PLATFORM =~ /java/
 
       describe "supposed response fields" do
         it "present" do
-          stub_request(:get, "http://www.example.com").to_return(:headers => {'X-Test' => '1'})
+          stub_request(:get, "http://www.example.com").to_return(headers: {'X-Test' => '1'})
           response = Typhoeus.get("http://www.example.com")
           expect(response.code).not_to be_nil
           expect(response.status_message).not_to be_nil
@@ -34,21 +34,21 @@ unless RUBY_PLATFORM =~ /java/
 
       describe "when params are used" do
         it "should take into account params for POST request" do
-          stub_request(:post, "www.example.com/?hello=world").with(:query => {:hello => 'world'})
-          request = Typhoeus::Request.new("http://www.example.com", :method => :post, :params => {:hello => 'world'})
+          stub_request(:post, "www.example.com/?hello=world").with(query: {hello: 'world'})
+          request = Typhoeus::Request.new("http://www.example.com", method: :post, params: {hello: 'world'})
           hydra.queue(request)
           hydra.run
         end
 
         it "should take into account body for POST request" do
-          stub_request(:post, "www.example.com").with(:body => {:hello => 'world'})
-          response = Typhoeus.post("http://www.example.com", :method => :post, :body => {:hello => 'world'})
+          stub_request(:post, "www.example.com").with(body: {hello: 'world'})
+          response = Typhoeus.post("http://www.example.com", method: :post, body: {hello: 'world'})
           expect(response.code).to eq(200)
         end
 
         it "should take into account params for GET request" do
           stub_request(:get, "http://www.example.com/?hello=world").to_return({})
-          request = Typhoeus::Request.new("http://www.example.com/?hello=world", :method => :get)
+          request = Typhoeus::Request.new("http://www.example.com/?hello=world", method: :get)
           hydra.queue(request)
           hydra.run
         end
@@ -58,7 +58,7 @@ unless RUBY_PLATFORM =~ /java/
         it "should support native typhoeus timeouts" do
           stub_request(:any, "example.com").to_timeout
 
-          request = Typhoeus::Request.new("http://example.com", :method => :get)
+          request = Typhoeus::Request.new("http://example.com", method: :get)
           hydra.queue(request)
           hydra.run
 
@@ -73,7 +73,7 @@ unless RUBY_PLATFORM =~ /java/
 
         it "should call on_complete 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
           Typhoeus.on_complete do |c|
@@ -86,7 +86,7 @@ unless RUBY_PLATFORM =~ /java/
 
         it "should call on_complete with 5xx response" do
           response_code = 599
-          stub_request(:any, "example.com").to_return(:status => [response_code, "Server On Fire"])
+          stub_request(:any, "example.com").to_return(status: [response_code, "Server On Fire"])
 
           test = nil
           Typhoeus.on_complete do |c|
@@ -99,7 +99,7 @@ unless RUBY_PLATFORM =~ /java/
 
         it "should call on_body with 2xx response" do
           body = "on_body fired"
-          stub_request(:any, "example.com").to_return(:body => body)
+          stub_request(:any, "example.com").to_return(body: body)
 
           test_body = nil
           test_complete = nil
@@ -118,7 +118,7 @@ unless RUBY_PLATFORM =~ /java/
 
         it "should call on_headers with 2xx response" do
           body = "on_headers fired"
-          stub_request(:any, "example.com").to_return(:body => body, :headers => {'X-Test' => '1'})
+          stub_request(:any, "example.com").to_return(body: body, headers: {'X-Test' => '1'})
 
           test_headers = nil
           skip("This test requires a newer version of Typhoeus") unless @request.respond_to?(:on_headers)

data/spec/acceptance/typhoeus/typhoeus_hydra_spec_helper.rb

@@ -8,10 +8,10 @@ module TyphoeusHydraSpecHelper
   def http_request(method, uri, options = {}, &block)
     uri.gsub!(" ", "%20") #typhoeus doesn't like spaces in the uri
     request_options =  {
-      :method  => method,
-      :body    => options[:body],
-      :headers => options[:headers],
-      :timeout => 25000
+      method: method,
+      body: options[:body],
+      headers: options[:headers],
+      timeout: 25000
     }
     if options[:basic_auth]
       request_options[:userpwd] = options[:basic_auth].join(':')
@@ -26,10 +26,10 @@ module TyphoeusHydraSpecHelper
     raise FakeTyphoeusHydraConnectError.new if response.return_code == :couldnt_connect
     raise FakeTyphoeusHydraTimeoutError.new if response.timed_out?
     OpenStruct.new({
-      :body => response.body,
-      :headers => WebMock::Util::Headers.normalize_headers(join_array_values(response.headers)),
-      :status => response.code.to_s,
-      :message => response.status_message
+      body: response.body,
+      headers: WebMock::Util::Headers.normalize_headers(join_array_values(response.headers)),
+      status: response.code.to_s,
+      message: response.status_message
     })
   end
 

data/spec/spec_helper.rb

@@ -21,16 +21,19 @@ require 'support/webmock_server'
 require 'support/my_rack_app'
 require 'support/failures'
 
+require 'simplecov'
+SimpleCov.start
+
 CURL_EXAMPLE_OUTPUT_PATH = File.expand_path('../support/example_curl_output.txt', __FILE__)
 
 RSpec.configure do |config|
   no_network_connection = ENV["NO_CONNECTION"] || ! NetworkConnection.is_network_available?
   if no_network_connection
     warn("No network connectivity. Only examples which do not make real network connections will run.")
-    config.filter_run_excluding :net_connect => true
+    config.filter_run_excluding net_connect: true
   end
 
-  config.filter_run_excluding :without_webmock => true
+  config.filter_run_excluding without_webmock: true
 
   config.before(:suite) do
     WebMockServer.instance.start unless WebMockServer.instance.started
@@ -40,7 +43,7 @@ RSpec.configure do |config|
     WebMockServer.instance.stop
   end
 
-  config.filter_run :focus => true
+  config.filter_run focus: true
   config.run_all_when_everything_filtered = true
 
   config.include Failures

data/spec/support/webmock_server.rb

@@ -23,7 +23,7 @@ class WebMockServer
 
   def start
     @started = true
-    server = WEBrick::GenericServer.new(:Port => 0, :Logger => Logger.new("/dev/null"))
+    server = WEBrick::GenericServer.new(Port: 0, Logger: Logger.new("/dev/null"))
     server.logger.level = 0
     @port = server.config[:Port]
 

data/spec/unit/api_spec.rb

@@ -4,7 +4,7 @@ describe WebMock::API do
   describe '#hash_including' do
 
     subject { klass.new.hash_including(args) }
-    let(:args) { {:data => :one} }
+    let(:args) { {data: :one} }
 
     context 'when mixed into a class that does not define `hash_including`' do
       let(:klass) do
@@ -35,7 +35,7 @@ describe WebMock::API do
       end
 
       context "when args are both keys and key/value pairs" do
-        subject {klass.new.hash_including(:foo, :bar, :data => :one)}
+        subject {klass.new.hash_including(:foo, :bar, data: :one)}
         let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
 
         it "creates 'HashIncludingMatcher' with keys anythingized" do

data/spec/unit/errors_spec.rb

@@ -120,10 +120,10 @@ describe "errors" do
       end
     end
 
-    let(:request_signature) { double(:request_signature, :to_s => rand(10**20).to_s) }
-    let(:stub_result)       { double(:stub_result, :to_s => rand(10**20).to_s) }
+    let(:request_signature) { double(:request_signature, to_s: rand(10**20).to_s) }
+    let(:stub_result)       { double(:stub_result, to_s: rand(10**20).to_s) }
     let(:request_stub)      { double(:request_stub) }
-    let(:body_pattern)      { double(:body_pattern, :body_pattern => nil)}
+    let(:body_pattern)      { double(:body_pattern, body_pattern: nil)}
     let(:body_diff)         { [["+", "test", "test2"], ["-", "test3"], ["~", "test5", "test6"]] }
   end
 end

data/spec/unit/matchers/hash_including_matcher_spec.rb

@@ -6,15 +6,15 @@ module WebMock
     describe HashIncludingMatcher do
 
       it "stringifies the given hash keys" do
-        expect(HashIncludingMatcher.new(:a => 1, :b => 2)).to eq("a" => 1, "b" => 2)
+        expect(HashIncludingMatcher.new(a: 1, b: 2)).to eq("a" => 1, "b" => 2)
       end
 
       it "sorts elements in the hash" do
-        expect(HashIncludingMatcher.new(:b => 2, :a => 1)).to eq("a" => 1, "b" => 2)
+        expect(HashIncludingMatcher.new(b: 2, a: 1)).to eq("a" => 1, "b" => 2)
       end
 
       it "describes itself properly" do
-        expect(HashIncludingMatcher.new(:a => 1).inspect).to eq "hash_including({\"a\"=>1})"
+        expect(HashIncludingMatcher.new(a: 1).inspect).to eq "hash_including({\"a\"=>1})"
       end
 
       describe "success" do
@@ -23,63 +23,63 @@ module WebMock
         end
 
         it "matches a hash with extra stuff" do
-          expect(HashIncludingMatcher.new(:a => 1)).to eq("a" => 1, "b" => 2)
+          expect(HashIncludingMatcher.new(a: 1)).to eq("a" => 1, "b" => 2)
         end
 
         describe "when matching anythingized keys" do
           let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
 
           it "matches an int against anything()" do
-            expect(HashIncludingMatcher.new(:a => anything, :b => 2)).to eq({'a' => 1, 'b' => 2})
+            expect(HashIncludingMatcher.new(a: anything, b: 2)).to eq({'a' => 1, 'b' => 2})
           end
 
           it "matches a string against anything()" do
-            expect(HashIncludingMatcher.new(:a => anything, :b => 2)).to eq({'a' => "1", 'b' => 2})
+            expect(HashIncludingMatcher.new(a: anything, b: 2)).to eq({'a' => "1", 'b' => 2})
           end
 
           it "matches if the key is present" do
-            expect(HashIncludingMatcher.new(:a => anything)).to eq({'a' => 1, 'b' => 2})
+            expect(HashIncludingMatcher.new(a: anything)).to eq({'a' => 1, 'b' => 2})
           end
 
           it "matches if more keys are present" do
-            expect(HashIncludingMatcher.new(:a => anything, :b => anything)).to eq({'a' => 1, 'b' => 2, 'c' => 3})
+            expect(HashIncludingMatcher.new(a: anything, b: anything)).to eq({'a' => 1, 'b' => 2, 'c' => 3})
           end
 
           it "matches if passed many keys and many key/value pairs" do
-            expect(HashIncludingMatcher.new(:a => anything, :b => anything, :c => 3, :e => 5)).to eq({'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5})
+            expect(HashIncludingMatcher.new(a: anything, b: anything, c: 3, e: 5)).to eq({'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5})
           end
         end
 
         describe "when matching an empty hash" do
           it "matches against any hash" do
-            expect(HashIncludingMatcher.new({})).to eq({:a => 1, :b => 2, :c => 3})
+            expect(HashIncludingMatcher.new({})).to eq({a: 1, b: 2, c: 3})
           end
         end
       end
 
       describe "failing" do
         it "does not match a non-hash" do
-          expect(HashIncludingMatcher.new(:a => 1)).not_to eq 1
+          expect(HashIncludingMatcher.new(a: 1)).not_to eq 1
         end
 
         it "does not match a hash with a missing key" do
-          expect(HashIncludingMatcher.new(:a => 1)).not_to eq('b' => 2)
+          expect(HashIncludingMatcher.new(a: 1)).not_to eq('b' => 2)
         end
 
         it "does not match an empty hash with a given key" do
-          expect(HashIncludingMatcher.new(:a => 1)).not_to eq({})
+          expect(HashIncludingMatcher.new(a: 1)).not_to eq({})
         end
 
         it "does not match a hash with a missing key when one pair is matching" do
-          expect(HashIncludingMatcher.new(:a => 1, :b => 2)).not_to eq('b' => 2)
+          expect(HashIncludingMatcher.new(a: 1, b: 2)).not_to eq('b' => 2)
         end
 
         it "does not match a hash with an incorrect value" do
-          expect(HashIncludingMatcher.new(:a => 1, :b => 2)).not_to eq('a' => 1, 'b' => 3)
+          expect(HashIncludingMatcher.new(a: 1, b: 2)).not_to eq('a' => 1, 'b' => 3)
         end
 
         it "does not match when values are nil but keys are different" do
-          expect(HashIncludingMatcher.new(:a => nil)).not_to eq('b' => nil)
+          expect(HashIncludingMatcher.new(a: nil)).not_to eq('b' => nil)
         end
       end
     end

data/spec/unit/rack_response_spec.rb

@@ -43,7 +43,7 @@ describe WebMock::RackResponse do
 
   it "should send along POST params" do
     request = WebMock::RequestSignature.new(:post, 'www.example.com/greet',
-      :body => 'name=Jimmy'
+      body: 'name=Jimmy'
     )
 
     response = @rack_response.evaluate(request)
@@ -52,7 +52,7 @@ describe WebMock::RackResponse do
 
   it "should send params with proper content length if params have non-ascii symbols" do
     request = WebMock::RequestSignature.new(:post, 'www.example.com/greet',
-      :body => 'name=Олег'
+      body: 'name=Олег'
     )
 
     response = @rack_response.evaluate(request)

data/spec/unit/request_body_diff_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe WebMock::RequestBodyDiff do
 
   let(:request_pattern) {
     WebMock::RequestPattern.new(
-      method, uri, {:body => request_stub_body}
+      method, uri, {body: request_stub_body}
     )
   }
 

data/spec/unit/request_execution_verifier_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe WebMock::RequestExecutionVerifier do
   before(:each) do
     @verifier = WebMock::RequestExecutionVerifier.new
-    @request_pattern = double(WebMock::RequestPattern, :to_s => "www.example.com")
+    @request_pattern = double(WebMock::RequestPattern, to_s: "www.example.com")
     @verifier.request_pattern = @request_pattern
     allow(WebMock::RequestRegistry.instance).to receive(:to_s).and_return("executed requests")
     @executed_requests_info = "\n\nThe following requests were made:\n\nexecuted requests\n" + "="*60

data/spec/unit/request_pattern_spec.rb

@@ -5,34 +5,34 @@ describe WebMock::RequestPattern do
   describe "describing itself" do
     it "should report string describing itself" do
       expect(WebMock::RequestPattern.new(:get, "www.example.com",
-      :body => "abc", :headers => {'A' => 'a', 'B' => 'b'}).to_s).to eq(
+      body: "abc", headers: {'A' => 'a', 'B' => 'b'}).to_s).to eq(
         "GET http://www.example.com/ with body \"abc\" with headers {'A'=>'a', 'B'=>'b'}"
       )
     end
 
     it "should report string describing itself with block" do
       expect(WebMock::RequestPattern.new(:get, "www.example.com",
-      :body => "abc", :headers => {'A' => 'a', 'B' => 'b'}).with {|req| true}.to_s).to eq(
+      body: "abc", headers: {'A' => 'a', 'B' => 'b'}).with {|req| true}.to_s).to eq(
         "GET http://www.example.com/ with body \"abc\" with headers {'A'=>'a', 'B'=>'b'} with given block"
       )
     end
 
     it "should report string describing itself with query params" do
-      expect(WebMock::RequestPattern.new(:get, /.*example.*/, :query => {'a' => ['b', 'c']}).to_s).to eq(
+      expect(WebMock::RequestPattern.new(:get, /.*example.*/, query: {'a' => ['b', 'c']}).to_s).to eq(
         "GET /.*example.*/ with query params {\"a\"=>[\"b\", \"c\"]}"
       )
     end
 
     it "should report string describing itself with query params as hash including matcher" do
       expect(WebMock::RequestPattern.new(:get, /.*example.*/,
-      :query => WebMock::Matchers::HashIncludingMatcher.new({'a' => ['b', 'c']})).to_s).to eq(
+      query: WebMock::Matchers::HashIncludingMatcher.new({'a' => ['b', 'c']})).to_s).to eq(
         "GET /.*example.*/ with query params hash_including({\"a\"=>[\"b\", \"c\"]})"
       )
     end
 
     it "should report string describing itself with body as hash including matcher" do
       expect(WebMock::RequestPattern.new(:get, /.*example.*/,
-      :body => WebMock::Matchers::HashIncludingMatcher.new({'a' => ['b', 'c']})).to_s).to eq(
+      body: WebMock::Matchers::HashIncludingMatcher.new({'a' => ['b', 'c']})).to_s).to eq(
         "GET /.*example.*/ with body hash_including({\"a\"=>[\"b\", \"c\"]})"
       )
     end
@@ -44,17 +44,17 @@ describe WebMock::RequestPattern do
     end
 
     it "should have assigned body pattern" do
-      @request_pattern.with(:body => "abc")
-      expect(@request_pattern.to_s).to eq(WebMock::RequestPattern.new(:get, "www.example.com", :body => "abc").to_s)
+      @request_pattern.with(body: "abc")
+      expect(@request_pattern.to_s).to eq(WebMock::RequestPattern.new(:get, "www.example.com", body: "abc").to_s)
     end
 
     it "should have assigned normalized headers pattern" do
-      @request_pattern.with(:headers => {'A' => 'a'})
-      expect(@request_pattern.to_s).to eq(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'A' => 'a'}).to_s)
+      @request_pattern.with(headers: {'A' => 'a'})
+      expect(@request_pattern.to_s).to eq(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'A' => 'a'}).to_s)
     end
 
     it "should raise an error if options passed to `with` are invalid" do
-      expect { @request_pattern.with(:foo => "bar") }.to raise_error('Unknown key: "foo". Valid keys are: "body", "headers", "query", "basic_auth"')
+      expect { @request_pattern.with(foo: "bar") }.to raise_error('Unknown key: "foo". Valid keys are: "body", "headers", "query", "basic_auth"')
     end
 
     it "should raise an error if neither options or block is provided" do
@@ -184,118 +184,118 @@ describe WebMock::RequestPattern do
 
       describe "when uri is described as regexp" do
         it "should match request query params" do
-          expect(WebMock::RequestPattern.new(:get, /.*example.*/, :query => {"a" => ["b", "c"]})).
+          expect(WebMock::RequestPattern.new(:get, /.*example.*/, query: {"a" => ["b", "c"]})).
             to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
         end
 
         it "should match request query params if params don't match" do
-          expect(WebMock::RequestPattern.new(:get, /.*example.*/, :query => {"x" => ["b", "c"]})).
+          expect(WebMock::RequestPattern.new(:get, /.*example.*/, query: {"x" => ["b", "c"]})).
             not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
         end
 
         it "should match when query params are declared as HashIncluding matcher matching params" do
           expect(WebMock::RequestPattern.new(:get, /.*example.*/,
-          :query => WebMock::Matchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+          query: WebMock::Matchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
             to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
         end
 
         it "should not match when query params are declared as HashIncluding matcher not matching params" do
           expect(WebMock::RequestPattern.new(:get, /.*example.*/,
-          :query => WebMock::Matchers::HashIncludingMatcher.new({"x" => ["b", "c"]}))).
+          query: WebMock::Matchers::HashIncludingMatcher.new({"x" => ["b", "c"]}))).
             not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
         end
 
         it "should match when query params are declared as RSpec HashIncluding matcher matching params" do
           expect(WebMock::RequestPattern.new(:get, /.*example.*/,
-          :query => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
             to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
         end
 
         it "should not match when query params are declared as RSpec HashIncluding matcher not matching params" do
           expect(WebMock::RequestPattern.new(:get, /.*example.*/,
-          :query => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "d"]}))).
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "d"]}))).
             not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
         end
       end
 
       describe "when uri is described as Addressable::Template" do
         it "should raise error if query params are specified" do
-          expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"), :query => {"a" => ["b", "c"]})).
+          expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"), query: {"a" => ["b", "c"]})).
             to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
         end
 
         it "should match request query params if params don't match" do
-          expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"), :query => {"x" => ["b", "c"]})).
+          expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"), query: {"x" => ["b", "c"]})).
             not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
         end
 
         it "should match when query params are declared as HashIncluding matcher matching params" do
           expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"),
-          :query => WebMock::Matchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+          query: WebMock::Matchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
             to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
         end
 
         it "should not match when query params are declared as HashIncluding matcher not matching params" do
           expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"),
-          :query => WebMock::Matchers::HashIncludingMatcher.new({"x" => ["b", "c"]}))).
+          query: WebMock::Matchers::HashIncludingMatcher.new({"x" => ["b", "c"]}))).
             not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
         end
 
         it "should match when query params are declared as RSpec HashIncluding matcher matching params" do
           expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"),
-          :query => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
             to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
         end
 
         it "should not match when query params are declared as RSpec HashIncluding matcher not matching params" do
           expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"),
-          :query => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "d"]}))).
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "d"]}))).
             not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
         end
       end
 
       describe "when uri is described as string" do
         it "should match when query params are the same as declared in hash" do
-          expect(WebMock::RequestPattern.new(:get, "www.example.com", :query => {"a" => ["b", "c"]})).
+          expect(WebMock::RequestPattern.new(:get, "www.example.com", query: {"a" => ["b", "c"]})).
             to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
         end
 
         it "should not match when query params are different than the declared in hash" do
-          expect(WebMock::RequestPattern.new(:get, "www.example.com", :query => {"a" => ["b", "c"]})).
+          expect(WebMock::RequestPattern.new(:get, "www.example.com", query: {"a" => ["b", "c"]})).
             not_to match(WebMock::RequestSignature.new(:get, "www.example.com?x[]=b&a[]=c"))
         end
 
         it "should match when query params are the same as declared as string" do
-          expect(WebMock::RequestPattern.new(:get, "www.example.com", :query => "a[]=b&a[]=c")).
+          expect(WebMock::RequestPattern.new(:get, "www.example.com", query: "a[]=b&a[]=c")).
             to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
         end
 
         it "should match when query params are the same as declared both in query option or url" do
-          expect(WebMock::RequestPattern.new(:get, "www.example.com/?x=3", :query => "a[]=b&a[]=c")).
+          expect(WebMock::RequestPattern.new(:get, "www.example.com/?x=3", query: "a[]=b&a[]=c")).
             to match(WebMock::RequestSignature.new(:get, "www.example.com/?x=3&a[]=b&a[]=c"))
         end
 
         it "should match when query params are declared as HashIncluding matcher matching params" do
           expect(WebMock::RequestPattern.new(:get, "www.example.com",
-          :query => WebMock::Matchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+          query: WebMock::Matchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
             to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
         end
 
         it "should not match when query params are declared as HashIncluding matcher not matching params" do
           expect(WebMock::RequestPattern.new(:get, "www.example.com",
-          :query => WebMock::Matchers::HashIncludingMatcher.new({"x" => ["b", "c"]}))).
+          query: WebMock::Matchers::HashIncludingMatcher.new({"x" => ["b", "c"]}))).
             not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
         end
 
         it "should match when query params are declared as RSpec HashIncluding matcher matching params" do
           expect(WebMock::RequestPattern.new(:get, "www.example.com",
-          :query => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
             to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
         end
 
         it "should not match when query params are declared as RSpec HashIncluding matcher not matching params" do
           expect(WebMock::RequestPattern.new(:get, "www.example.com",
-          :query => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "d"]}))).
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "d"]}))).
             not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
         end
 
@@ -305,7 +305,7 @@ describe WebMock::RequestPattern do
           end
 
           it "should not match when repeated query params are not the same as declared as string" do
-            expect(WebMock::RequestPattern.new(:get, "www.example.com", :query => "a=b&a=c")).
+            expect(WebMock::RequestPattern.new(:get, "www.example.com", query: "a=b&a=c")).
               to match(WebMock::RequestSignature.new(:get, "www.example.com?a=b&a=c"))
           end
 
@@ -319,42 +319,42 @@ describe WebMock::RequestPattern do
     describe "when matching requests with body" do
 
       it "should match if request body and body pattern are the same" do
-        expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => "abc")).
-          to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: "abc")).
+          to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))
       end
 
       it "should match if request body matches regexp" do
-        expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => /^abc$/)).
-          to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: /^abc$/)).
+          to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))
       end
 
       it "should not match if body pattern is different than request body" do
-        expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => "def")).
-          not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: "def")).
+          not_to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))
       end
 
       it "should not match if request body doesn't match regexp pattern" do
-        expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => /^abc$/)).
-          not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "xabc"))
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: /^abc$/)).
+          not_to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "xabc"))
       end
 
       it "should match if pattern doesn't have specified body" do
         expect(WebMock::RequestPattern.new(:get, "www.example.com")).
-          to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))
+          to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))
       end
 
       it "should not match if pattern has body specified as nil but request body is not empty" do
-        expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => nil)).
-          not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: nil)).
+          not_to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))
       end
 
       it "should not match if pattern has empty body but request body is not empty" do
-        expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => "")).
-          not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: "")).
+          not_to match(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))
       end
 
       it "should not match if pattern has body specified but request has no body" do
-        expect(WebMock::RequestPattern.new(:get, "www.example.com", :body => "abc")).
+        expect(WebMock::RequestPattern.new(:get, "www.example.com", body: "abc")).
           not_to match(WebMock::RequestSignature.new(:get, "www.example.com"))
       end
 
@@ -363,89 +363,89 @@ describe WebMock::RequestPattern do
 
         describe "for request with url encoded body" do
           it "should match when hash matches body" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
-              to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'a=1&c[d][]=e&c[d][]=f&b=five'))
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+              to match(WebMock::RequestSignature.new(:post, "www.example.com", body: 'a=1&c[d][]=e&c[d][]=f&b=five'))
           end
 
           it "should match when hash matches body in different order of params" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
-              to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'a=1&c[d][]=e&b=five&c[d][]=f'))
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+              to match(WebMock::RequestSignature.new(:post, "www.example.com", body: 'a=1&c[d][]=e&b=five&c[d][]=f'))
           end
 
           it "should not match when hash doesn't match url encoded body" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
-              not_to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'c[d][]=f&a=1&c[d][]=e'))
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+              not_to match(WebMock::RequestSignature.new(:post, "www.example.com", body: 'c[d][]=f&a=1&c[d][]=e'))
           end
 
           it "should not match when body is not url encoded" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
-              not_to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'foo bar'))
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+              not_to match(WebMock::RequestSignature.new(:post, "www.example.com", body: 'foo bar'))
           end
 
           it "should match when hash contains regex values" do
-            expect(WebMock::RequestPattern.new(:post, "www.example.com", :body => {:a => /^\w{5}$/, :b => {:c => /^\d{3}$/}})).
-              to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'a=abcde&b[c]=123'))
+            expect(WebMock::RequestPattern.new(:post, "www.example.com", body: {a: /^\w{5}$/, b: {c: /^\d{3}$/}})).
+              to match(WebMock::RequestSignature.new(:post, "www.example.com", body: 'a=abcde&b[c]=123'))
           end
 
           it "should not match when hash does not contains regex values" do
-            expect(WebMock::RequestPattern.new(:post, "www.example.com", :body => {:a => /^\d+$/, :b => {:c => /^\d{3}$/}})).
-              not_to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'a=abcde&b[c]=123'))
+            expect(WebMock::RequestPattern.new(:post, "www.example.com", body: {a: /^\d+$/, b: {c: /^\d{3}$/}})).
+              not_to match(WebMock::RequestSignature.new(:post, "www.example.com", body: 'a=abcde&b[c]=123'))
           end
 
           context 'body is an hash with an array of hashes' do
-            let(:body_hash) { {:a => [{'b' => '1'}, {'b' => '2'}]} }
+            let(:body_hash) { {a: [{'b' => '1'}, {'b' => '2'}]} }
 
             it "should match when hash matches body" do
-              expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
-                to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'a[][b]=1&a[][b]=2'))
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+                to match(WebMock::RequestSignature.new(:post, "www.example.com", body: 'a[][b]=1&a[][b]=2'))
             end
           end
 
           context 'body is an hash with an array of hashes with multiple keys' do
-            let(:body_hash) { {:a => [{'b' => '1', 'a' => '2'}, {'b' => '3'}]} }
+            let(:body_hash) { {a: [{'b' => '1', 'a' => '2'}, {'b' => '3'}]} }
 
             it "should match when hash matches body" do
-              expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
-                to match(WebMock::RequestSignature.new(:post, "www.example.com", :body => 'a[][b]=1&a[][a]=2&a[][b]=3'))
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+                to match(WebMock::RequestSignature.new(:post, "www.example.com", body: 'a[][b]=1&a[][a]=2&a[][b]=3'))
             end
           end
         end
 
         describe "for request with json body and content type is set to json" do
           it "should match when hash matches body" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
-              to match(WebMock::RequestSignature.new(:post, "www.example.com", :headers => {:content_type => 'application/json'},
-                                                         :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}"))
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+              to match(WebMock::RequestSignature.new(:post, "www.example.com", headers: {content_type: 'application/json'},
+                                                         body: "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}"))
               end
 
           it "should match if hash matches body in different form" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
-              to match(WebMock::RequestSignature.new(:post, "www.example.com", :headers => {:content_type => 'application/json'},
-                                                         :body => "{\"a\":\"1\",\"b\":\"five\",\"c\":{\"d\":[\"e\",\"f\"]}}"))
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+              to match(WebMock::RequestSignature.new(:post, "www.example.com", headers: {content_type: 'application/json'},
+                                                         body: "{\"a\":\"1\",\"b\":\"five\",\"c\":{\"d\":[\"e\",\"f\"]}}"))
               end
 
           it "should not match when body is not json" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
               not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
-                                                             :headers => {:content_type => 'application/json'}, :body => "foo bar"))
+                                                             headers: {content_type: 'application/json'}, body: "foo bar"))
           end
 
           it "should not match if request body is different" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => {:a => 1, :b => 2})).
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: {a: 1, b: 2})).
               not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
-              :headers => {:content_type => 'application/json'}, :body => "{\"a\":1,\"c\":null}"))
+              headers: {content_type: 'application/json'}, body: "{\"a\":1,\"c\":null}"))
           end
 
           it "should not match if request body is has less params than pattern" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => {:a => 1, :b => 2})).
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: {a: 1, b: 2})).
               not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
-              :headers => {:content_type => 'application/json'}, :body => "{\"a\":1}"))
+              headers: {content_type: 'application/json'}, body: "{\"a\":1}"))
           end
 
           it "should not match if request body is has more params than pattern" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => {:a => 1})).
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: {a: 1})).
               not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
-              :headers => {:content_type => 'application/json'}, :body => "{\"a\":1,\"c\":1}"))
+              headers: {content_type: 'application/json'}, body: "{\"a\":1,\"c\":1}"))
           end
         end
 
@@ -453,119 +453,119 @@ describe WebMock::RequestPattern do
           let(:body_hash) { {"opt" => {:a => '1', :b => 'five', 'c' => {'d' => ['e', 'f']}}} }
 
           it "should match when hash matches body" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
-              to match(WebMock::RequestSignature.new(:post, "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"))
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+              to match(WebMock::RequestSignature.new(:post, "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"))
               end
 
           it "should match if hash matches body in different form" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
-              to match(WebMock::RequestSignature.new(:post, "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"))
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+              to match(WebMock::RequestSignature.new(:post, "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"))
               end
 
           it "should not match when body is not xml" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
               not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
-                                                             :headers => {:content_type => 'application/xml'}, :body => "foo bar"))
+                                                             headers: {content_type: 'application/xml'}, body: "foo bar"))
               end
 
           it "matches when the content type include a charset" do
-            expect(WebMock::RequestPattern.new(:post, 'www.example.com', :body => body_hash)).
-              to match(WebMock::RequestSignature.new(:post, "www.example.com", :headers => {:content_type => 'application/xml;charset=UTF-8'},
-                                                         :body => "<opt a=\"1\" b=\"five\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n"))
+            expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
+              to match(WebMock::RequestSignature.new(:post, "www.example.com", headers: {content_type: 'application/xml;charset=UTF-8'},
+                                                         body: "<opt a=\"1\" b=\"five\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n"))
 
           end
         end
       end
 
       describe "when body in a pattern is declared as a partial hash matcher" do
-        let(:signature) { WebMock::RequestSignature.new(:post, "www.example.com", :body => 'a=1&c[d][]=e&c[d][]=f&b=five') }
+        let(:signature) { WebMock::RequestSignature.new(:post, "www.example.com", body: 'a=1&c[d][]=e&c[d][]=f&b=five') }
 
        it "should match when query params are declared as HashIncluding matcher matching params" do
           expect(WebMock::RequestPattern.new(:post, "www.example.com",
-          :body => WebMock::Matchers::HashIncludingMatcher.new({:a => '1', 'c' => {'d' => ['e', 'f']}}))).
+          body: WebMock::Matchers::HashIncludingMatcher.new({:a => '1', 'c' => {'d' => ['e', 'f']}}))).
             to match(signature)
         end
 
         it "should not match when query params are declared as HashIncluding matcher not matching params" do
           expect(WebMock::RequestPattern.new(:post, "www.example.com",
-          :body => WebMock::Matchers::HashIncludingMatcher.new({:x => '1', 'c' => {'d' => ['e', 'f']}}))).
+          body: WebMock::Matchers::HashIncludingMatcher.new({:x => '1', 'c' => {'d' => ['e', 'f']}}))).
             not_to match(signature)
         end
 
         it "should match when query params are declared as RSpec HashIncluding matcher matching params" do
           expect(WebMock::RequestPattern.new(:post, "www.example.com",
-          :body => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({:a => '1', 'c' => {'d' => ['e', 'f']}}))).
+          body: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({:a => '1', 'c' => {'d' => ['e', 'f']}}))).
             to match(signature)
         end
 
         it "should not match when query params are declared as RSpec HashIncluding matcher not matching params" do
           expect(WebMock::RequestPattern.new(:post, "www.example.com",
-          :body => RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({:x => '1', 'c' => {'d' => ['e', 'f']}}))).
+          body: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({:x => '1', 'c' => {'d' => ['e', 'f']}}))).
             not_to match(signature)
         end
       end
     end
 
     it "should match if pattern and request have the same headers" do
-      expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'})).
-        to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg'})).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg'}))
     end
 
     it "should match if pattern headers values are regexps matching request header values" do
-      expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => %r{^image/jpeg$}})).
-        to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'Content-Type' => %r{^image/jpeg$}})).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg'}))
     end
 
     it "should not match if pattern has different value of header than request" do
-      expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/png'})).
-        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'Content-Type' => 'image/png'})).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg'}))
     end
 
     it "should not match if pattern header value regexp doesn't match request header value" do
-      expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => %r{^image\/jpeg$}})).
-        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpegx'}))
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'Content-Type' => %r{^image\/jpeg$}})).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpegx'}))
     end
 
     it "should match if request has more headers than request pattern" do
-      expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'})).
-        to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'}))
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg'})).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'}))
     end
 
     it "should not match if request has less headers than the request pattern" do
-      expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'})).
-        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'})).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'Content-Type' => 'image/jpeg'}))
     end
 
     it "should match even is header keys are declared in different form" do
-      expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'ContentLength' => '8888', 'Content-type' => 'image/png'})).
-        to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {:ContentLength => 8888, 'content_type' => 'image/png'}))
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'ContentLength' => '8888', 'Content-type' => 'image/png'})).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {:ContentLength => 8888, 'content_type' => 'image/png'}))
     end
 
     it "should match is pattern doesn't have specified headers" do
       expect(WebMock::RequestPattern.new(:get, "www.example.com")).
-        to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}))
+        to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'A' => 'a'}))
     end
 
     it "should not match if pattern has nil headers but request has headers" do
-      expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => nil)).
-        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}))
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: nil)).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'A' => 'a'}))
     end
 
     it "should not match if pattern has empty headers but request has headers" do
-      expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {})).
-        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}))
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {})).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {'A' => 'a'}))
     end
 
     it "should not match if pattern has specified headers but request has nil headers" do
-      expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'A'=>'a'})).
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'A'=>'a'})).
         not_to match(WebMock::RequestSignature.new(:get, "www.example.com"))
     end
 
     it "should not match if pattern has specified headers but request has empty headers" do
-      expect(WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'A'=>'a'})).
-        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", :headers => {}))
+      expect(WebMock::RequestPattern.new(:get, "www.example.com", headers: {'A'=>'a'})).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com", headers: {}))
     end
 
     it "should match if block given in pattern evaluates request to true" do