webmock 1.20.3 → 1.20.4

data/spec/unit/request_registry_spec.rb

@@ -14,9 +14,9 @@ describe WebMock::RequestRegistry do
     end
 
     it "should clean list of executed requests" do
-      WebMock::RequestRegistry.instance.times_executed(@request_pattern).should == 1
+      expect(WebMock::RequestRegistry.instance.times_executed(@request_pattern)).to eq(1)
       WebMock::RequestRegistry.instance.reset!
-      WebMock::RequestRegistry.instance.times_executed(@request_pattern).should == 0
+      expect(WebMock::RequestRegistry.instance.times_executed(@request_pattern)).to eq(0)
     end
 
   end
@@ -33,15 +33,15 @@ describe WebMock::RequestRegistry do
     end
 
     it "should report 0 if no request matching pattern was requested" do
-      WebMock::RequestRegistry.instance.times_executed(WebMock::RequestPattern.new(:get, "www.example.net")).should == 0
+      expect(WebMock::RequestRegistry.instance.times_executed(WebMock::RequestPattern.new(:get, "www.example.net"))).to eq(0)
     end
 
     it "should report number of times matching pattern was requested" do
-      WebMock::RequestRegistry.instance.times_executed(WebMock::RequestPattern.new(:get, "www.example.com")).should == 2
+      expect(WebMock::RequestRegistry.instance.times_executed(WebMock::RequestPattern.new(:get, "www.example.com"))).to eq(2)
     end
 
     it "should report number of times all matching pattern were requested" do
-      WebMock::RequestRegistry.instance.times_executed(WebMock::RequestPattern.new(:get, /.*example.*/)).should == 3
+      expect(WebMock::RequestRegistry.instance.times_executed(WebMock::RequestPattern.new(:get, /.*example.*/))).to eq(3)
     end
   end
 
@@ -49,8 +49,8 @@ describe WebMock::RequestRegistry do
     it "should return hash of unique request signatures with accumulated number" do
       WebMock::RequestRegistry.instance.requested_signatures.put(WebMock::RequestSignature.new(:get, "www.example.com"))
       WebMock::RequestRegistry.instance.requested_signatures.put(WebMock::RequestSignature.new(:get, "www.example.com"))
-      WebMock::RequestRegistry.instance.requested_signatures.
-        get(WebMock::RequestSignature.new(:get, "www.example.com")).should == 2
+      expect(WebMock::RequestRegistry.instance.requested_signatures.
+        get(WebMock::RequestSignature.new(:get, "www.example.com"))).to eq(2)
     end
   end
 
@@ -63,12 +63,13 @@ describe WebMock::RequestRegistry do
       ].each do |s|
         WebMock::RequestRegistry.instance.requested_signatures.put(s)
       end
-      WebMock::RequestRegistry.instance.to_s.should ==
+      expect(WebMock::RequestRegistry.instance.to_s).to eq(
       "GET http://www.example.com/ was made 2 times\nPUT http://www.example.org/ was made 1 time\n"
+      )
     end
 
     it "should output info if no requests were executed" do
-      WebMock::RequestRegistry.instance.to_s.should == "No requests were made."
+      expect(WebMock::RequestRegistry.instance.to_s).to eq("No requests were made.")
     end
   end
 

data/spec/unit/request_signature_spec.rb

@@ -5,36 +5,37 @@ describe WebMock::RequestSignature do
   describe "initialization" do
 
     it "should have assigned normalized uri" do
-      WebMock::Util::URI.should_receive(:normalize_uri).and_return("www.example.kom")
+      expect(WebMock::Util::URI).to receive(:normalize_uri).and_return("www.example.kom")
       signature = WebMock::RequestSignature.new(:get, "www.example.com")
-      signature.uri.should == "www.example.kom"
+      expect(signature.uri).to eq("www.example.kom")
     end
 
     it "should have assigned uri without normalization if uri is URI" do
-      WebMock::Util::URI.should_not_receive(:normalize_uri)
+      expect(WebMock::Util::URI).not_to receive(:normalize_uri)
       uri = Addressable::URI.parse("www.example.com")
       signature = WebMock::RequestSignature.new(:get, uri)
-      signature.uri.should == uri
+      expect(signature.uri).to eq(uri)
     end
 
     it "should have assigned normalized headers" do
-      WebMock::Util::Headers.should_receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
-      WebMock::RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}).headers.should == {'B' => 'b'}
+      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).to eq({'B' => 'b'})
     end
 
     it "should have assigned body" do
-      WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc").body.should == "abc"
+      expect(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc").body).to eq("abc")
     end
 
     it "should symbolize the method" do
-      WebMock::RequestSignature.new('get', "www.example.com", :body => "abc").method.should == :get
+      expect(WebMock::RequestSignature.new('get', "www.example.com", :body => "abc").method).to eq(:get)
     end
   end
 
   it "should report string describing itself" do
-    WebMock::RequestSignature.new(:get, "www.example.com",
-      :body => "abc", :headers => {'A' => 'a', 'B' => 'b'}).to_s.should ==
+    expect(WebMock::RequestSignature.new(:get, "www.example.com",
+      :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
 
   describe "hash" do
@@ -43,25 +44,25 @@ describe WebMock::RequestSignature do
         :body => "abc", :headers => {'A' => 'a', 'B' => 'b'})
       signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
         :body => "abc", :headers => {'A' => 'a', 'B' => 'b'})
-      signature1.hash.should == signature2.hash
+      expect(signature1.hash).to eq(signature2.hash)
     end
 
     it "should report different hash for two signatures with different method" do
       signature1 = WebMock::RequestSignature.new(:get, "www.example.com")
       signature2 = WebMock::RequestSignature.new(:put, "www.example.com")
-      signature1.hash.should_not == signature2.hash
+      expect(signature1.hash).not_to eq(signature2.hash)
     end
 
     it "should report different hash for two signatures with different uri" do
       signature1 = WebMock::RequestSignature.new(:get, "www.example.com")
       signature2 = WebMock::RequestSignature.new(:get, "www.example.org")
-      signature1.hash.should_not == signature2.hash
+      expect(signature1.hash).not_to eq(signature2.hash)
     end
 
     it "should report 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.hash.should_not == signature2.hash
+      expect(signature1.hash).not_to eq(signature2.hash)
     end
 
     it "should report different hash for two signatures with different headers" do
@@ -69,7 +70,7 @@ describe WebMock::RequestSignature do
         :headers => {'A' => 'a'})
       signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
         :headers => {'A' => 'A'})
-      signature1.hash.should_not == signature2.hash
+      expect(signature1.hash).not_to eq(signature2.hash)
     end
   end
 
@@ -82,25 +83,25 @@ describe WebMock::RequestSignature do
         signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
           :body => "abc", :headers => {'A' => 'a', 'B' => 'b'})
 
-        signature1.send(method, signature2).should be_true
+        expect(signature1.send(method, signature2)).to be_truthy
       end
 
       it "should be false for two signatures with different method" do
         signature1 = WebMock::RequestSignature.new(:get, "www.example.com")
         signature2 = WebMock::RequestSignature.new(:put, "www.example.com")
-        signature1.send(method, signature2).should be_false
+        expect(signature1.send(method, signature2)).to be_falsey
       end
 
       it "should be false for two signatures with different uri" do
         signature1 = WebMock::RequestSignature.new(:get, "www.example.com")
         signature2 = WebMock::RequestSignature.new(:get, "www.example.org")
-        signature1.send(method, signature2).should be_false
+        expect(signature1.send(method, signature2)).to be_falsey
       end
 
       it "should be 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.send(method, signature2).should be_false
+        expect(signature1.send(method, signature2)).to be_falsey
       end
 
       it "should be false for two signatures with different headers" do
@@ -108,7 +109,7 @@ describe WebMock::RequestSignature do
           :headers => {'A' => 'a'})
         signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
           :headers => {'A' => 'A'})
-        signature1.send(method, signature2).should be_false
+        expect(signature1.send(method, signature2)).to be_falsey
       end
     end
   end

data/spec/unit/request_stub_spec.rb

@@ -7,29 +7,30 @@ describe WebMock::RequestStub do
   end
 
   it "should have request pattern with method and uri" do
-    @request_stub.request_pattern.to_s.should == "GET http://www.example.com/"
+    expect(@request_stub.request_pattern.to_s).to eq("GET http://www.example.com/")
   end
 
   it "should have response" do
-    @request_stub.response.should be_a(WebMock::Response)
+    expect(@request_stub.response).to be_a(WebMock::Response)
   end
 
   describe "with" do
 
     it "should assign body to request pattern" do
       @request_stub.with(:body => "abc")
-      @request_stub.request_pattern.to_s.should == WebMock::RequestPattern.new(:get, "www.example.com", :body => "abc").to_s
+      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.request_pattern.to_s.should ==
+      expect(@request_stub.request_pattern.to_s).to eq(
         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" }
-      @request_stub.request_pattern.matches?(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc")).should be_true
+      expect(@request_stub.request_pattern.matches?(WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc"))).to be_truthy
     end
 
   end
@@ -38,20 +39,20 @@ describe WebMock::RequestStub do
 
     it "should assign response with provided options" do
       @request_stub.to_return(:body => "abc", :status => 500)
-      @request_stub.response.body.should == "abc"
-      @request_stub.response.status.should == [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.response.body, @request_stub.response.body].should == ["abc", "def"]
+      expect([@request_stub.response.body, @request_stub.response.body]).to eq(["abc", "def"])
     end
 
   end
 
   describe "then" do
     it "should return stub without any modifications, acting as syntactic sugar" do
-      @request_stub.then.should == @request_stub
+      expect(@request_stub.then).to eq(@request_stub)
     end
   end
 
@@ -59,27 +60,27 @@ describe WebMock::RequestStub do
 
     it "should return responses in a sequence passed as array" do
       @request_stub.to_return([{:body => "abc"}, {:body => "def"}])
-      @request_stub.response.body.should == "abc"
-      @request_stub.response.body.should == "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.response
       @request_stub.response
-      @request_stub.response.body.should == "def"
+      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.response.body.should == "abc"
-      @request_stub.response.body.should == "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.response.body.should == "abc"
-      @request_stub.response.body.should == "def"
+      expect(@request_stub.response.body).to eq("abc")
+      expect(@request_stub.response.body).to eq("def")
     end
 
   end
@@ -88,37 +89,37 @@ describe WebMock::RequestStub do
 
     it "should assign response with exception to be thrown" do
       @request_stub.to_raise(ArgumentError)
-      lambda {
+      expect {
         @request_stub.response.raise_error_if_any
-      }.should raise_error(ArgumentError, "Exception from WebMock")
+      }.to raise_error(ArgumentError, "Exception from WebMock")
     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.response.body.should == "abc"
-      lambda {
+      expect(@request_stub.response.body).to eq("abc")
+      expect {
         @request_stub.response.raise_error_if_any
-      }.should raise_error(ArgumentError, "Exception from WebMock")
+      }.to raise_error(ArgumentError, "Exception from WebMock")
     end
 
     it "should assign a list responses to be thrown in a sequence" do
       @request_stub.to_raise(ArgumentError, IndexError)
-      lambda {
+      expect {
         @request_stub.response.raise_error_if_any
-      }.should raise_error(ArgumentError, "Exception from WebMock")
-      lambda {
+      }.to raise_error(ArgumentError, "Exception from WebMock")
+      expect {
         @request_stub.response.raise_error_if_any
-      }.should raise_error(IndexError, "Exception from WebMock")
+      }.to raise_error(IndexError, "Exception from WebMock")
     end
 
     it "should raise exceptions declared in multiple to_raise declarations" do
        @request_stub.to_raise(ArgumentError).then.to_raise(IndexError)
-        lambda {
+        expect {
           @request_stub.response.raise_error_if_any
-        }.should raise_error(ArgumentError, "Exception from WebMock")
-        lambda {
+        }.to raise_error(ArgumentError, "Exception from WebMock")
+        expect {
           @request_stub.response.raise_error_if_any
-        }.should raise_error(IndexError, "Exception from WebMock")
+        }.to raise_error(IndexError, "Exception from WebMock")
     end
 
   end
@@ -127,20 +128,20 @@ describe WebMock::RequestStub do
 
      it "should assign response with timeout" do
        @request_stub.to_timeout
-       @request_stub.response.should_timeout.should be_true
+       expect(@request_stub.response.should_timeout).to be_truthy
      end
 
      it "should assign sequence of responses with response with timeout" do
        @request_stub.to_return(:body => "abc").then.to_timeout
-       @request_stub.response.body.should == "abc"
-       @request_stub.response.should_timeout.should be_true
+       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.response.should_timeout.should be_true
-       @request_stub.response.should_timeout.should be_true
-       @request_stub.response.body.should == "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")
      end
 
    end
@@ -149,48 +150,48 @@ describe WebMock::RequestStub do
   describe "times" do
 
     it "should give error if declared before any response declaration is declared" do
-      lambda {
+      expect {
         @request_stub.times(3)
-       }.should raise_error("Invalid WebMock stub declaration. times(N) can be declared only after response declaration.")
+       }.to raise_error("Invalid WebMock stub declaration. times(N) can be declared only after response declaration.")
     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.response.body.should == "abc"
-      @request_stub.response.body.should == "abc"
-      @request_stub.response.body.should == "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.response.body.should == "abc"
-      @request_stub.response.body.should == "abc"
-      @request_stub.response.body.should == "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.response.body.should == "abc"
-      @request_stub.response.body.should == "def"
-      @request_stub.response.body.should == "abc"
-      @request_stub.response.body.should == "def"
-      @request_stub.response.body.should == "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")
+      expect(@request_stub.response.body).to eq("def")
+      expect(@request_stub.response.body).to eq("ghj")
     end
 
     it "should return self" do
-      @request_stub.to_return({:body => "abc"}).times(1).should == @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
-      lambda {
+      expect {
          @request_stub.to_return({:body => "abc"}).times("not number")
-      }.should raise_error("times(N) accepts integers >= 1 only")
+      }.to raise_error("times(N) accepts integers >= 1 only")
     end
 
     it "should raise error if argument is < 1" do
-      lambda {
+      expect {
         @request_stub.to_return({:body => "abc"}).times(0)
-      }.should raise_error("times(N) accepts integers >= 1 only")
+      }.to raise_error("times(N) accepts integers >= 1 only")
     end
 
   end

data/spec/unit/response_spec.rb

@@ -6,15 +6,15 @@ describe WebMock::ResponseFactory do
 
     it "should create response with options passed as arguments" do
       options = {:body => "abc", :headers => {:a => :b}}
-      WebMock::Response.should_receive(:new).with(options).and_return(@response = double(WebMock::Response))
-      WebMock::ResponseFactory.response_for(options).should == @response
+      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"})
-      WebMock::DynamicResponse.should_receive(:new).with(callable).and_return(@response = double(WebMock::Response))
-      WebMock::ResponseFactory.response_for(callable).should == @response
+      expect(WebMock::DynamicResponse).to receive(:new).with(callable).and_return(@response = double(WebMock::Response))
+      expect(WebMock::ResponseFactory.response_for(callable)).to eq(@response)
     end
 
   end
@@ -31,24 +31,24 @@ describe WebMock::Response do
   end
 
   it "should report normalized headers" do
-    WebMock::Util::Headers.should_receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
+    expect(WebMock::Util::Headers).to receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
     @response = WebMock::Response.new(:headers => {'A' => 'a'})
-    @response.headers.should == {'B' => 'b'}
+    expect(@response.headers).to eq({'B' => 'b'})
   end
 
   describe "status" do
     it "should have 200 code and empty message by default" do
-      @response.status.should == [200, ""]
+      expect(@response.status).to eq([200, ""])
     end
 
     it "should return assigned status" do
       @response = WebMock::Response.new(:status => 500)
-      @response.status.should == [500, ""]
+      expect(@response.status).to eq([500, ""])
     end
 
     it "should return assigned message" do
       @response = WebMock::Response.new(:status => [500, "Internal Server Error"])
-      @response.status.should == [500, "Internal Server Error"]
+      expect(@response.status).to eq([500, "Internal Server Error"])
     end
   end
 
@@ -56,23 +56,23 @@ describe WebMock::Response do
 
     it "should raise error if any assigned" do
       @response = WebMock::Response.new(:exception => ArgumentError)
-      lambda {
+      expect {
         @response.raise_error_if_any
-      }.should raise_error(ArgumentError, "Exception from WebMock")
+      }.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"))
-      lambda {
+      expect {
         @response.raise_error_if_any
-      }.should raise_error(ArgumentError, "hello world")
+      }.to raise_error(ArgumentError, "hello world")
     end
 
     it "should raise error if any assigned as string" do
       @response = WebMock::Response.new(:exception => "hello world")
-      lambda {
+      expect {
         @response.raise_error_if_any
-      }.should raise_error("hello world")
+      }.to raise_error("hello world")
     end
 
     it "should not raise error if no error assigned" do
@@ -85,12 +85,12 @@ describe WebMock::Response do
 
     it "should know if it should timeout" do
       @response = WebMock::Response.new(:should_timeout => true)
-      @response.should_timeout.should be_true
+      expect(@response.should_timeout).to be_truthy
     end
 
     it "should not timeout by default" do
       @response = WebMock::Response.new
-      @response.should_timeout.should be_false
+      expect(@response.should_timeout).to be_falsey
     end
 
   end
@@ -98,40 +98,40 @@ describe WebMock::Response do
   describe "body" do
 
     it "should return empty body by default" do
-      @response.body.should == ''
+      expect(@response.body).to eq('')
     end
 
     it "should report body if assigned" do
       @response = WebMock::Response.new(:body => "abc")
-      @response.body.should == "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.body.should == __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.body.should == File.read(__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.body.should == File.read(__FILE__)
-      @response.body.should == File.read(__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.body.should == File.read(__FILE__)
+      expect(@response.body).to eq(File.read(__FILE__))
     end
 
     # Users of webmock commonly make the mistake of stubbing the response
     # body to return a hash, to prevent this:
     #
     it "should error if not given one of the allowed types" do
-      lambda { WebMock::Response.new(:body => Hash.new) }.should \
+      expect { WebMock::Response.new(:body => Hash.new) }.to \
         raise_error(WebMock::Response::InvalidBody)
     end
 
@@ -147,25 +147,25 @@ describe WebMock::Response do
 
 
       it "should read status" do
-        @response.status.should == [202, "OK"]
+        expect(@response.status).to eq([202, "OK"])
       end
 
       it "should read headers" do
-        @response.headers.should == {
+        expect(@response.headers).to eq({
           "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
           "Content-Type"=>"text/html; charset=UTF-8",
           "Content-Length"=>"419",
           "Connection"=>"Keep-Alive",
           "Accept"=>"image/jpeg, image/png"
-          }
+          })
       end
 
       it "should read body" do
-        @response.body.size.should == 419
+        expect(@response.body.size).to eq(419)
       end
 
       it "should close IO" do
-        @file.should be_closed
+        expect(@file).to be_closed
       end
 
     end
@@ -177,27 +177,27 @@ describe WebMock::Response do
       end
 
       it "should read status" do
-        @response.status.should == [202, "OK"]
+        expect(@response.status).to eq([202, "OK"])
       end
 
       it "should read headers" do
-        @response.headers.should == {
+        expect(@response.headers).to eq({
           "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
           "Content-Type"=>"text/html; charset=UTF-8",
           "Content-Length"=>"419",
           "Connection"=>"Keep-Alive",
           "Accept"=>"image/jpeg, image/png"
-          }
+          })
       end
 
       it "should read body" do
-        @response.body.size.should == 419
+        expect(@response.body.size).to eq(419)
       end
 
       it "should work with transfer-encoding set to chunked" do
         @input.gsub!("Content-Length: 419", "Transfer-Encoding: chunked")
         @response = WebMock::Response.new(@input)
-        @response.body.size.should == 419
+        expect(@response.body.size).to eq(419)
       end
 
     end
@@ -210,17 +210,17 @@ describe WebMock::Response do
 
       it "should have evaluated body" do
         @response = WebMock::Response.new(:body => lambda {|request| request.body})
-        @response.evaluate(@request_signature).body.should == "abc"
+        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.evaluate(@request_signature).headers.should == {'A' => 'a'}
+        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.evaluate(@request_signature).status.should == [302, ""]
+        expect(@response.evaluate(@request_signature).status).to eq([302, ""])
       end
 
     end
@@ -241,16 +241,16 @@ describe WebMock::Response do
           }
         })
         evaluated_response = response.evaluate(request_signature)
-        evaluated_response.body.should == "abc"
-        evaluated_response.headers.should == {'A' => 'a'}
-        evaluated_response.status.should == [302, ""]
+        expect(evaluated_response.body).to eq("abc")
+        expect(evaluated_response.headers).to eq({'A' => 'a'})
+        expect(evaluated_response.status).to eq([302, ""])
       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}})
         evaluated_response = response.evaluate(request_signature)
-        evaluated_response.should == WebMock::Response.new(:body => "abc")
+        expect(evaluated_response).to eq(WebMock::Response.new(:body => "abc"))
       end
 
       describe "when raw response is evaluated" do
@@ -264,14 +264,14 @@ describe WebMock::Response do
         describe "as a file" do
           it "should return response" do
             response = WebMock::DynamicResponse.new(lambda {|request| @files[request.uri.host.to_s] })
-            response.evaluate(@request_signature).body.size.should == 419
+            expect(response.evaluate(@request_signature).body.size).to eq(419)
           end
         end
 
         describe "as a string" do
           it "should return response" do
             response = WebMock::DynamicResponse.new(lambda {|request| @files[request.uri.host.to_s].read })
-            response.evaluate(@request_signature).body.size.should == 419
+            expect(response.evaluate(@request_signature).body.size).to eq(419)
           end
         end
       end