webmock 2.0.3 → 2.1.0

data/spec/unit/request_signature_snippet_spec.rb

@@ -13,7 +13,7 @@ RSpec.describe WebMock::RequestSignatureSnippet do
 
   let(:request_pattern) {
     WebMock::RequestPattern.new(
-      method, uri, {:body => request_signature_body}
+      method, uri, {body: request_signature_body}
     )
   }
 
@@ -48,7 +48,7 @@ RSpec.describe WebMock::RequestSignatureSnippet do
 
   describe "#request_stubs" do
     before :each do
-      WebMock.stub_request(:get, "https://www.example.com").with(:body => {"a" => "b"})
+      WebMock.stub_request(:get, "https://www.example.com").with(body: {"a" => "b"})
     end
 
     context "when showing the body diff is turned off" do

data/spec/unit/request_signature_spec.rb

@@ -20,23 +20,23 @@ describe WebMock::RequestSignature do
     it "assigns normalized headers" do
       expect(WebMock::Util::Headers).to receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
       expect(
-        WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}).headers
+        WebMock::RequestSignature.new(:get, "www.example.com", headers: {'A' => 'a'}).headers
       ).to eq({'B' => 'b'})
     end
 
     it "assign the body" do
-      expect(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc").body).to eq("abc")
+      expect(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc").body).to eq("abc")
     end
 
     it "symbolizes the method" do
-      expect(WebMock::RequestSignature.new('get', "www.example.com", :body => "abc").method).to eq(:get)
+      expect(WebMock::RequestSignature.new('get', "www.example.com", body: "abc").method).to eq(:get)
     end
   end
 
   describe "#to_s" do
     it "describes itself" do
       expect(WebMock::RequestSignature.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
@@ -45,9 +45,9 @@ describe WebMock::RequestSignature do
   describe "#hash" do
     it "reporst same hash for two signatures with the same values" do
       signature1 = WebMock::RequestSignature.new(:get, "www.example.com",
-        :body => "abc", :headers => {'A' => 'a', 'B' => 'b'})
+        body: "abc", headers: {'A' => 'a', 'B' => 'b'})
       signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
-        :body => "abc", :headers => {'A' => 'a', 'B' => 'b'})
+        body: "abc", headers: {'A' => 'a', 'B' => 'b'})
       expect(signature1.hash).to eq(signature2.hash)
     end
 
@@ -64,16 +64,16 @@ describe WebMock::RequestSignature do
     end
 
     it "reports different hash for two signatures with different body" do
-      signature1 = WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc")
-      signature2 = WebMock::RequestSignature.new(:get, "www.example.com", :body => "def")
+      signature1 = WebMock::RequestSignature.new(:get, "www.example.com", body: "abc")
+      signature2 = WebMock::RequestSignature.new(:get, "www.example.com", body: "def")
       expect(signature1.hash).not_to eq(signature2.hash)
     end
 
     it "reports different hash for two signatures with different headers" do
       signature1 = WebMock::RequestSignature.new(:get, "www.example.com",
-        :headers => {'A' => 'a'})
+        headers: {'A' => 'a'})
       signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
-        :headers => {'A' => 'A'})
+        headers: {'A' => 'A'})
       expect(signature1.hash).not_to eq(signature2.hash)
     end
   end
@@ -82,9 +82,9 @@ describe WebMock::RequestSignature do
     describe method do
       it "is true for two signatures with the same values" do
         signature1 = WebMock::RequestSignature.new(:get, "www.example.com",
-          :body => "abc", :headers => {'A' => 'a', 'B' => 'b'})
+          body: "abc", headers: {'A' => 'a', 'B' => 'b'})
         signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
-          :body => "abc", :headers => {'A' => 'a', 'B' => 'b'})
+          body: "abc", headers: {'A' => 'a', 'B' => 'b'})
 
         expect(signature1.send(method, signature2)).to be_truthy
       end
@@ -102,16 +102,16 @@ describe WebMock::RequestSignature do
       end
 
       it "is false for two signatures with different body" do
-        signature1 = WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc")
-        signature2 = WebMock::RequestSignature.new(:get, "www.example.com", :body => "def")
+        signature1 = WebMock::RequestSignature.new(:get, "www.example.com", body: "abc")
+        signature2 = WebMock::RequestSignature.new(:get, "www.example.com", body: "def")
         expect(signature1.send(method, signature2)).to be_falsey
       end
 
       it "is false for two signatures with different headers" do
         signature1 = WebMock::RequestSignature.new(:get, "www.example.com",
-          :headers => {'A' => 'a'})
+          headers: {'A' => 'a'})
         signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
-          :headers => {'A' => 'A'})
+          headers: {'A' => 'A'})
         expect(signature1.send(method, signature2)).to be_falsey
       end
     end

data/spec/unit/request_stub_spec.rb

@@ -17,20 +17,20 @@ describe WebMock::RequestStub do
   describe "with" do
 
     it "should assign body to request pattern" do
-      @request_stub.with(:body => "abc")
-      expect(@request_stub.request_pattern.to_s).to eq(WebMock::RequestPattern.new(:get, "www.example.com", :body => "abc").to_s)
+      @request_stub.with(body: "abc")
+      expect(@request_stub.request_pattern.to_s).to eq(WebMock::RequestPattern.new(:get, "www.example.com", body: "abc").to_s)
     end
 
     it "should assign normalized headers to request pattern" do
-      @request_stub.with(:headers => {'A' => 'a'})
+      @request_stub.with(headers: {'A' => 'a'})
       expect(@request_stub.request_pattern.to_s).to eq(
-        WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'A' => 'a'}).to_s
+        WebMock::RequestPattern.new(:get, "www.example.com", headers: {'A' => 'a'}).to_s
       )
     end
 
     it "should assign given block to request profile" do
       @request_stub.with { |req| req.body == "abc" }
-      expect(@request_stub.request_pattern.matches?(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))).to be_truthy
+      expect(@request_stub.request_pattern.matches?(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))).to be_truthy
     end
 
   end
@@ -38,13 +38,13 @@ describe WebMock::RequestStub do
   describe "to_return" do
 
     it "should assign response with provided options" do
-      @request_stub.to_return(:body => "abc", :status => 500)
+      @request_stub.to_return(body: "abc", status: 500)
       expect(@request_stub.response.body).to eq("abc")
       expect(@request_stub.response.status).to eq([500, ""])
     end
 
     it "should assign responses with provided options" do
-      @request_stub.to_return([{:body => "abc"}, {:body => "def"}])
+      @request_stub.to_return([{body: "abc"}, {body: "def"}])
       expect([@request_stub.response.body, @request_stub.response.body]).to eq(["abc", "def"])
     end
 
@@ -59,26 +59,26 @@ describe WebMock::RequestStub do
   describe "response" do
 
     it "should return responses in a sequence passed as array" do
-      @request_stub.to_return([{:body => "abc"}, {:body => "def"}])
+      @request_stub.to_return([{body: "abc"}, {body: "def"}])
       expect(@request_stub.response.body).to eq("abc")
       expect(@request_stub.response.body).to eq("def")
     end
 
     it "should repeat returning last response" do
-      @request_stub.to_return([{:body => "abc"}, {:body => "def"}])
+      @request_stub.to_return([{body: "abc"}, {body: "def"}])
       @request_stub.response
       @request_stub.response
       expect(@request_stub.response.body).to eq("def")
     end
 
     it "should return responses in a sequence passed as comma separated params" do
-      @request_stub.to_return({:body => "abc"}, {:body => "def"})
+      @request_stub.to_return({body: "abc"}, {body: "def"})
       expect(@request_stub.response.body).to eq("abc")
       expect(@request_stub.response.body).to eq("def")
     end
 
     it "should return responses declared in multiple to_return declarations" do
-      @request_stub.to_return({:body => "abc"}).to_return({:body => "def"})
+      @request_stub.to_return({body: "abc"}).to_return({body: "def"})
       expect(@request_stub.response.body).to eq("abc")
       expect(@request_stub.response.body).to eq("def")
     end
@@ -95,7 +95,7 @@ describe WebMock::RequestStub do
     end
 
     it "should assign sequence of responses with response with exception to be thrown" do
-      @request_stub.to_return(:body => "abc").then.to_raise(ArgumentError)
+      @request_stub.to_return(body: "abc").then.to_raise(ArgumentError)
       expect(@request_stub.response.body).to eq("abc")
       expect {
         @request_stub.response.raise_error_if_any
@@ -132,13 +132,13 @@ describe WebMock::RequestStub do
      end
 
      it "should assign sequence of responses with response with timeout" do
-       @request_stub.to_return(:body => "abc").then.to_timeout
+       @request_stub.to_return(body: "abc").then.to_timeout
        expect(@request_stub.response.body).to eq("abc")
        expect(@request_stub.response.should_timeout).to be_truthy
      end
 
      it "should allow multiple timeouts to be declared" do
-       @request_stub.to_timeout.then.to_timeout.then.to_return(:body => "abc")
+       @request_stub.to_timeout.then.to_timeout.then.to_return(body: "abc")
        expect(@request_stub.response.should_timeout).to be_truthy
        expect(@request_stub.response.should_timeout).to be_truthy
        expect(@request_stub.response.body).to eq("abc")
@@ -156,21 +156,21 @@ describe WebMock::RequestStub do
     end
 
     it "should repeat returning last declared response declared number of times" do
-      @request_stub.to_return({:body => "abc"}).times(2).then.to_return({:body => "def"})
+      @request_stub.to_return({body: "abc"}).times(2).then.to_return({body: "def"})
       expect(@request_stub.response.body).to eq("abc")
       expect(@request_stub.response.body).to eq("abc")
       expect(@request_stub.response.body).to eq("def")
     end
 
     it "should repeat raising last declared exception declared number of times" do
-      @request_stub.to_return({:body => "abc"}).times(2).then.to_return({:body => "def"})
+      @request_stub.to_return({body: "abc"}).times(2).then.to_return({body: "def"})
       expect(@request_stub.response.body).to eq("abc")
       expect(@request_stub.response.body).to eq("abc")
       expect(@request_stub.response.body).to eq("def")
     end
 
     it "should repeat returning last declared sequence of responses declared number of times" do
-      @request_stub.to_return({:body => "abc"}, {:body => "def"}).times(2).then.to_return({:body => "ghj"})
+      @request_stub.to_return({body: "abc"}, {body: "def"}).times(2).then.to_return({body: "ghj"})
       expect(@request_stub.response.body).to eq("abc")
       expect(@request_stub.response.body).to eq("def")
       expect(@request_stub.response.body).to eq("abc")
@@ -179,18 +179,18 @@ describe WebMock::RequestStub do
     end
 
     it "should return self" do
-      expect(@request_stub.to_return({:body => "abc"}).times(1)).to eq(@request_stub)
+      expect(@request_stub.to_return({body: "abc"}).times(1)).to eq(@request_stub)
     end
 
     it "should raise error if argument is not integer" do
       expect {
-         @request_stub.to_return({:body => "abc"}).times("not number")
+         @request_stub.to_return({body: "abc"}).times("not number")
       }.to raise_error("times(N) accepts integers >= 1 only")
     end
 
     it "should raise error if argument is < 1" do
       expect {
-        @request_stub.to_return({:body => "abc"}).times(0)
+        @request_stub.to_return({body: "abc"}).times(0)
       }.to raise_error("times(N) accepts integers >= 1 only")
     end
 

data/spec/unit/response_spec.rb

@@ -5,14 +5,14 @@ describe WebMock::ResponseFactory do
   describe "response_for" do
 
     it "should create response with options passed as arguments" do
-      options = {:body => "abc", :headers => {:a => :b}}
+      options = {body: "abc", headers: {a: :b}}
       expect(WebMock::Response).to receive(:new).with(options).and_return(@response = double(WebMock::Response))
       expect(WebMock::ResponseFactory.response_for(options)).to eq(@response)
     end
 
 
     it "should create dynamic response for argument responding to call" do
-      callable = double(:call => {:body => "abc"})
+      callable = double(call: {body: "abc"})
       expect(WebMock::DynamicResponse).to receive(:new).with(callable).and_return(@response = double(WebMock::Response))
       expect(WebMock::ResponseFactory.response_for(callable)).to eq(@response)
     end
@@ -23,16 +23,16 @@ end
 
 describe WebMock::Response do
   before(:each) do
-    @response = WebMock::Response.new(:headers => {'A' => 'a'})
+    @response = WebMock::Response.new(headers: {'A' => 'a'})
   end
 
   it "should raise an error when initialized with unknown option" do
-    expect { WebMock::Response.new(:foo => "bar") }.to raise_error('Unknown key: "foo". Valid keys are: "headers", "status", "body", "exception", "should_timeout"')
+    expect { WebMock::Response.new(foo: "bar") }.to raise_error('Unknown key: "foo". Valid keys are: "headers", "status", "body", "exception", "should_timeout"')
   end
 
   it "should report normalized headers" do
     expect(WebMock::Util::Headers).to receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
-    @response = WebMock::Response.new(:headers => {'A' => 'a'})
+    @response = WebMock::Response.new(headers: {'A' => 'a'})
     expect(@response.headers).to eq({'B' => 'b'})
   end
 
@@ -42,12 +42,12 @@ describe WebMock::Response do
     end
 
     it "should return assigned status" do
-      @response = WebMock::Response.new(:status => 500)
+      @response = WebMock::Response.new(status: 500)
       expect(@response.status).to eq([500, ""])
     end
 
     it "should return assigned message" do
-      @response = WebMock::Response.new(:status => [500, "Internal Server Error"])
+      @response = WebMock::Response.new(status: [500, "Internal Server Error"])
       expect(@response.status).to eq([500, "Internal Server Error"])
     end
   end
@@ -55,21 +55,21 @@ describe WebMock::Response do
   describe "raising error" do
 
     it "should raise error if any assigned" do
-      @response = WebMock::Response.new(:exception => ArgumentError)
+      @response = WebMock::Response.new(exception: ArgumentError)
       expect {
         @response.raise_error_if_any
       }.to raise_error(ArgumentError, "Exception from WebMock")
     end
 
     it "should raise error if any assigned as instance" do
-      @response = WebMock::Response.new(:exception => ArgumentError.new("hello world"))
+      @response = WebMock::Response.new(exception: ArgumentError.new("hello world"))
       expect {
         @response.raise_error_if_any
       }.to raise_error(ArgumentError, "hello world")
     end
 
     it "should raise error if any assigned as string" do
-      @response = WebMock::Response.new(:exception => "hello world")
+      @response = WebMock::Response.new(exception: "hello world")
       expect {
         @response.raise_error_if_any
       }.to raise_error("hello world")
@@ -84,7 +84,7 @@ describe WebMock::Response do
   describe "timeout" do
 
     it "should know if it should timeout" do
-      @response = WebMock::Response.new(:should_timeout => true)
+      @response = WebMock::Response.new(should_timeout: true)
       expect(@response.should_timeout).to be_truthy
     end
 
@@ -102,28 +102,28 @@ describe WebMock::Response do
     end
 
     it "should report body if assigned" do
-      @response = WebMock::Response.new(:body => "abc")
+      @response = WebMock::Response.new(body: "abc")
       expect(@response.body).to eq("abc")
     end
 
     it "should report string even if existing file path was provided" do
-      @response = WebMock::Response.new(:body => __FILE__)
+      @response = WebMock::Response.new(body: __FILE__)
       expect(@response.body).to eq(__FILE__)
     end
 
     it "should report content of a IO object if provided" do
-      @response = WebMock::Response.new(:body => File.new(__FILE__))
+      @response = WebMock::Response.new(body: File.new(__FILE__))
       expect(@response.body).to eq(File.read(__FILE__))
     end
 
     it "should report many times content of a IO object if provided" do
-      @response = WebMock::Response.new(:body => File.new(__FILE__))
+      @response = WebMock::Response.new(body: File.new(__FILE__))
       expect(@response.body).to eq(File.read(__FILE__))
       expect(@response.body).to eq(File.read(__FILE__))
     end
 
     it "should work with Pathnames" do
-      @response = WebMock::Response.new(:body => Pathname.new(__FILE__))
+      @response = WebMock::Response.new(body: Pathname.new(__FILE__))
       expect(@response.body).to eq(File.read(__FILE__))
     end
 
@@ -131,7 +131,7 @@ describe WebMock::Response do
     # body to return a hash, to prevent this:
     #
     it "should error if not given one of the allowed types" do
-      expect { WebMock::Response.new(:body => Hash.new) }.to \
+      expect { WebMock::Response.new(body: Hash.new) }.to \
         raise_error(WebMock::Response::InvalidBody)
     end
 
@@ -205,21 +205,21 @@ describe WebMock::Response do
     describe "with dynamically evaluated options" do
 
       before(:each) do
-        @request_signature = WebMock::RequestSignature.new(:post, "www.example.com", :body => "abc", :headers => {'A' => 'a'})
+        @request_signature = WebMock::RequestSignature.new(:post, "www.example.com", body: "abc", headers: {'A' => 'a'})
       end
 
       it "should have evaluated body" do
-        @response = WebMock::Response.new(:body => lambda {|request| request.body})
+        @response = WebMock::Response.new(body: lambda {|request| request.body})
         expect(@response.evaluate(@request_signature).body).to eq("abc")
       end
 
       it "should have evaluated headers" do
-        @response = WebMock::Response.new(:headers => lambda {|request| request.headers})
+        @response = WebMock::Response.new(headers: lambda {|request| request.headers})
         expect(@response.evaluate(@request_signature).headers).to eq({'A' => 'a'})
       end
 
       it "should have evaluated status" do
-        @response = WebMock::Response.new(:status => lambda {|request| 302})
+        @response = WebMock::Response.new(status: lambda {|request| 302})
         expect(@response.evaluate(@request_signature).status).to eq([302, ""])
       end
 
@@ -232,12 +232,12 @@ describe WebMock::Response do
     describe "evaluating response options" do
 
       it "should evaluate new response with evaluated options" do
-        request_signature = WebMock::RequestSignature.new(:post, "www.example.com", :body => "abc", :headers => {'A' => 'a'})
+        request_signature = WebMock::RequestSignature.new(:post, "www.example.com", body: "abc", headers: {'A' => 'a'})
         response = WebMock::DynamicResponse.new(lambda {|request|
           {
-            :body => request.body,
-            :headers => request.headers,
-            :status => 302
+            body: request.body,
+            headers: request.headers,
+            status: 302
           }
         })
         evaluated_response = response.evaluate(request_signature)
@@ -247,10 +247,10 @@ describe WebMock::Response do
       end
 
       it "should be equal to static response after evaluation" do
-        request_signature = WebMock::RequestSignature.new(:post, "www.example.com", :body => "abc")
-        response = WebMock::DynamicResponse.new(lambda {|request| {:body => request.body}})
+        request_signature = WebMock::RequestSignature.new(:post, "www.example.com", body: "abc")
+        response = WebMock::DynamicResponse.new(lambda {|request| {body: request.body}})
         evaluated_response = response.evaluate(request_signature)
-        expect(evaluated_response).to eq(WebMock::Response.new(:body => "abc"))
+        expect(evaluated_response).to eq(WebMock::Response.new(body: "abc"))
       end
 
       describe "when raw response is evaluated" do

data/spec/unit/stub_registry_spec.rb

@@ -51,21 +51,21 @@ describe WebMock::StubRegistry do
   describe "response for request" do
 
     it "should report registered evaluated response for request pattern" do
-      @request_stub.to_return(:body => "abc")
+      @request_stub.to_return(body: "abc")
       WebMock::StubRegistry.instance.register_request_stub(@request_stub)
       expect(WebMock::StubRegistry.instance.response_for_request(@request_signature)).
-        to eq(WebMock::Response.new(:body => "abc"))
+        to eq(WebMock::Response.new(body: "abc"))
     end
 
     it "should report evaluated response" do
-      @request_stub.to_return {|request| {:body => request.method.to_s} }
+      @request_stub.to_return {|request| {body: request.method.to_s} }
       WebMock::StubRegistry.instance.register_request_stub(@request_stub)
       response1 = WebMock::StubRegistry.instance.response_for_request(@request_signature)
-      expect(response1).to eq(WebMock::Response.new(:body => "get"))
+      expect(response1).to eq(WebMock::Response.new(body: "get"))
     end
 
     it "should report clone of the response" do
-      @request_stub.to_return(:body => lambda{|r| r.method.to_s})
+      @request_stub.to_return(body: lambda{|r| r.method.to_s})
       WebMock::StubRegistry.instance.register_request_stub(@request_stub)
       response1 = WebMock::StubRegistry.instance.response_for_request(@request_signature)
       response2 = WebMock::StubRegistry.instance.response_for_request(@request_signature)
@@ -73,7 +73,7 @@ describe WebMock::StubRegistry do
     end
 
     it "should report clone of the dynamic response" do
-      @request_stub.to_return {|request| {:body => request.method.to_s} }
+      @request_stub.to_return {|request| {body: request.method.to_s} }
       WebMock::StubRegistry.instance.register_request_stub(@request_stub)
       response1 = WebMock::StubRegistry.instance.response_for_request(@request_signature)
       response2 = WebMock::StubRegistry.instance.response_for_request(@request_signature)
@@ -86,16 +86,16 @@ describe WebMock::StubRegistry do
 
     it "should always return last registered matching response" do
       @request_stub1 = WebMock::RequestStub.new(:get, "www.example.com")
-      @request_stub1.to_return(:body => "abc")
+      @request_stub1.to_return(body: "abc")
       @request_stub2 = WebMock::RequestStub.new(:get, "www.example.com")
-      @request_stub2.to_return(:body => "def")
+      @request_stub2.to_return(body: "def")
       @request_stub3 = WebMock::RequestStub.new(:get, "www.example.org")
-      @request_stub3.to_return(:body => "ghj")
+      @request_stub3.to_return(body: "ghj")
       WebMock::StubRegistry.instance.register_request_stub(@request_stub1)
       WebMock::StubRegistry.instance.register_request_stub(@request_stub2)
       WebMock::StubRegistry.instance.register_request_stub(@request_stub3)
       expect(WebMock::StubRegistry.instance.response_for_request(@request_signature)).
-        to eq(WebMock::Response.new(:body => "def"))
+        to eq(WebMock::Response.new(body: "def"))
     end
 
   end