webmock 1.8.6 → 3.14.0

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,34 @@ 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
+
+    describe "multithreading" do
+      let(:request_pattern) { WebMock::RequestPattern.new(:get, "www.example.com") }
+
+      # Reproduce a multithreading issue that causes a RuntimeError:
+      #   can't add a new key into hash during iteration.
+      it "works normally iterating on the requested signature hash while another thread is setting it" do
+        thread_injected = false
+        allow(request_pattern).to receive(:matches?).and_wrap_original do |m, *args|
+          unless thread_injected
+            thread_injected = true
+            Thread.new { WebMock::RequestRegistry.instance.requested_signatures.put(:abc) }.join(0.1)
+          end
+          m.call(*args)
+        end
+        expect(WebMock::RequestRegistry.instance.times_executed(request_pattern)).to eq(2)
+        sleep 0.1 while !WebMock::RequestRegistry.instance.requested_signatures.hash.key?(:abc)
+      end
     end
   end
 
@@ -49,8 +68,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 +82,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_snippet_spec.rb

@@ -0,0 +1,89 @@
+require "spec_helper"
+
+RSpec.describe WebMock::RequestSignatureSnippet do
+  it("is real"){expect{subject}.not_to(raise_error)}
+
+  subject { WebMock::RequestSignatureSnippet.new(request_signature) }
+
+  let(:uri) { "http://example.com" }
+  let(:method) { "GET" }
+
+  let(:request_signature) { WebMock::RequestSignature.new(method, uri) }
+  let(:request_signature_body) { {"key" => "different value"}.to_json }
+
+  let(:request_pattern) {
+    WebMock::RequestPattern.new(
+      method, uri, {body: request_signature_body}
+    )
+  }
+
+  before :each do
+    request_signature.headers = {"Content-Type" => "application/json"}
+    request_signature.body = request_signature_body
+  end
+
+  describe "#stubbing_instructions" do
+    context "with stubbing instructions turned off" do
+      before :each do
+        WebMock.hide_stubbing_instructions!
+      end
+
+      it "returns nil" do
+        expect(subject.stubbing_instructions).to be nil
+      end
+
+      after :each do
+        WebMock.show_stubbing_instructions!
+      end
+    end
+
+    context "with stubbing instructions turned on" do
+      it "returns a stub snippet" do
+        expect(subject.stubbing_instructions).to include(
+          "You can stub this request with the following snippet:"
+        )
+      end
+    end
+  end
+
+  describe "#request_stubs" do
+    before :each do
+      WebMock.stub_request(:get, "https://www.example.com").with(body: {"a" => "b"})
+    end
+
+    context "when showing the body diff is turned off" do
+      before :each do
+        WebMock.hide_body_diff!
+      end
+
+      it "returns does not show the body diff" do
+        result = subject.request_stubs
+        result.sub!("registered request stubs:\n\n", "")
+        expect(result).to eq(
+          "stub_request(:get, \"https://www.example.com/\").\n  with(\n    body: {\"a\"=>\"b\"})"
+        )
+      end
+
+      after :each do
+        WebMock.show_body_diff!
+      end
+    end
+
+    context "when showing the body diff is turned on" do
+      it "shows the body diff" do
+        result = subject.request_stubs
+        result.sub!("registered request stubs:\n\n", "")
+        expect(result).to eq(
+          "stub_request(:get, \"https://www.example.com/\").\n  with(\n    body: {\"a\"=>\"b\"})\n\nBody diff:\n [[\"-\", \"key\", \"different value\"], [\"+\", \"a\", \"b\"]]\n"
+        )
+      end
+    end
+
+    context "with no request stubs" do
+      it "returns nil" do
+        WebMock.reset!
+        expect(subject.request_stubs).to be nil
+      end
+    end
+  end
+end

data/spec/unit/request_signature_spec.rb

@@ -4,110 +4,152 @@ 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")
+    it "assign the uri to be the normalized uri" do
+      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)
+    it "assigns the uri without normalization if uri is already a URI" do
+      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'}
+    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
+      ).to eq({'B' => 'b'})
     end
 
-    it "should have assigned body" do
-      WebMock::RequestSignature.new(:get, "www.example.com", :body => "abc").body.should == "abc"
+    it "assign the body" do
+      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)
+    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 ==
-    "GET http://www.example.com/ with body 'abc' with headers {'A'=>'a', 'B'=>'b'}"
+  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(
+      "GET http://www.example.com/ with body 'abc' with headers {'A'=>'a', 'B'=>'b'}"
+      )
+    end
   end
 
-  describe "hash" do
-    it "should report same hash for two signatures with the same values" 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'})
-      signature1.hash.should == signature2.hash
+        body: "abc", headers: {'A' => 'a', 'B' => 'b'})
+      expect(signature1.hash).to eq(signature2.hash)
     end
 
-    it "should report different hash for two signatures with different method" do
+    it "reports 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
+    it "reports 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
+    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")
+      expect(signature1.hash).not_to eq(signature2.hash)
     end
 
-    it "should report different hash for two signatures with different headers" do
+    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'})
-      signature1.hash.should_not == signature2.hash
+        headers: {'A' => 'A'})
+      expect(signature1.hash).not_to eq(signature2.hash)
     end
   end
 
-
   [:==, :eql?].each do |method|
     describe method do
-      it "should be true for two signatures with the same values" 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'})
 
-        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
+      it "is 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
+      it "is 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
+      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")
+        expect(signature1.send(method, signature2)).to be_falsey
       end
 
-      it "should be false for two signatures with different headers" do
+      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'})
-        signature1.send(method, signature2).should be_false
+          headers: {'A' => 'A'})
+        expect(signature1.send(method, signature2)).to be_falsey
       end
     end
   end
 
+  subject { WebMock::RequestSignature.new(:get, "www.example.com") }
+
+  describe "#url_encoded?" do
+    it "returns true if the headers are urlencoded" do
+      subject.headers = { "Content-Type" => "application/x-www-form-urlencoded" }
+      expect(subject.url_encoded?).to be true
+    end
+
+    it "returns false if the headers are NOT urlencoded" do
+      subject.headers = { "Content-Type" => "application/made-up-format" }
+      expect(subject.url_encoded?).to be false
+    end
+
+    it "returns false when no headers are set" do
+      subject.headers = nil
+      expect(subject.url_encoded?).to be false
+    end
+  end
+
+  describe "#json_headers?" do
+    it "returns true if the headers are json" do
+      subject.headers = { "Content-Type" => "application/json" }
+      expect(subject.json_headers?).to be true
+    end
+
+    it "returns false if the headers are NOT json" do
+      subject.headers = { "Content-Type" => "application/made-up-format" }
+      expect(subject.json_headers?).to be false
+    end
+
+    it "returns false when no headers are set" do
+      subject.headers = nil
+      expect(subject.json_headers?).to be false
+    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
+      @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.request_pattern.to_s.should ==
-        WebMock::RequestPattern.new(:get, "www.example.com", :headers => {'A' => 'a'}).to_s
+      @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
+      )
     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
@@ -37,49 +38,49 @@ 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.response.body.should == "abc"
-      @request_stub.response.status.should == [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.response.body, @request_stub.response.body].should == ["abc", "def"]
+      @request_stub.to_return([{body: "abc"}, {body: "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
 
   describe "response" 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"
+      @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
-      @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"
+      @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.response.body.should == "abc"
-      @request_stub.response.body.should == "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
 
   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 {
+      @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
-      }.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
+       @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.response.should_timeout.should be_true
-       @request_stub.response.should_timeout.should be_true
-       @request_stub.response.body.should == "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")
      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"
+      @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.response.body.should == "abc"
-      @request_stub.response.body.should == "abc"
-      @request_stub.response.body.should == "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.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"
+      @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")
+      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 {
-         @request_stub.to_return({:body => "abc"}).times("not number")
-      }.should raise_error("times(N) accepts integers >= 1 only")
+      expect {
+         @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
-      lambda {
-        @request_stub.to_return({:body => "abc"}).times(0)
-      }.should raise_error("times(N) accepts integers >= 1 only")
+      expect {
+        @request_stub.to_return({body: "abc"}).times(0)
+      }.to raise_error("times(N) accepts integers >= 1 only")
     end
 
   end