webmock 1.20.3 → 1.20.4

data/spec/acceptance/excon/excon_spec.rb

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

data/spec/acceptance/httpclient/httpclient_spec.rb

@@ -20,14 +20,14 @@ describe "HTTPClient" do
     http_request(:get, "http://www.example.com/") do |body|
       response_body = body
     end
-    response_body.should == "abc"
+    expect(response_body).to eq("abc")
   end
 
   it "should match requests if headers are the same  but in different order" do
     stub_request(:get, "www.example.com").with(:headers => {"a" => ["b", "c"]} )
-    http_request(
+    expect(http_request(
       :get, "http://www.example.com/",
-    :headers => {"a" => ["c", "b"]}).status.should == "200"
+    :headers => {"a" => ["c", "b"]}).status).to eq("200")
   end
 
   describe "when using async requests" do
@@ -44,7 +44,7 @@ describe "HTTPClient" do
     HTTPClient.get_content('www.example.com') do |content|
       str << content
     end
-    str.should == 'test'
+    expect(str).to eq('test')
   end
 
   context "multipart bodies" do
@@ -91,12 +91,12 @@ describe "HTTPClient" do
     end
 
     it "supports request filters" do
-      @client.request(:get, 'http://www.example.com/').status.should == 200
+      expect(@client.request(:get, 'http://www.example.com/').status).to eq(200)
     end
 
     it "supports response filters" do
       res = @client.request(:get, 'http://www.example.com/')
-      res.header['X-Powered-By'].first.should == 'webmock'
+      expect(res.header['X-Powered-By'].first).to eq('webmock')
     end
   end
 
@@ -121,9 +121,9 @@ describe "HTTPClient" do
                          :headers => { "Cookie" => "bar=; foo=" })
       http_request(:get, webmock_server_url, :client => client)
 
-      request_signatures.should have(2).signatures
+      expect(request_signatures.size).to eq(2)
       # Verify the request signatures were identical as needed by this example
-      request_signatures.first.should eq(request_signatures.last)
+      expect(request_signatures.first).to eq(request_signatures.last)
     end
   end
 
@@ -157,7 +157,7 @@ describe "HTTPClient" do
     it 'receives request_method, request_uri, and request_query from the request header' do
       stub_request :get, 'www.example.com'
       message = HTTPClient.new.get 'www.example.com'
-      message.header.request_uri.to_s.should == 'www.example.com'
+      expect(message.header.request_uri.to_s).to eq('www.example.com')
     end
   end
 end

data/spec/acceptance/net_http/net_http_shared.rb

@@ -8,7 +8,7 @@ shared_examples_for "Net::HTTP" do
 
     it "should return a Net::ReadAdapter from response.body when a real request is made with a block and #read_body", :net_connect => true do
       response = Net::HTTP.new("localhost", port).request_get('/') { |r| r.read_body { } }
-      response.body.should be_a(Net::ReadAdapter)
+      expect(response.body).to be_a(Net::ReadAdapter)
     end
 
     it "should handle requests with block passed to read_body", :net_connect => true do
@@ -21,7 +21,7 @@ shared_examples_for "Net::HTTP" do
           end
         end
       end
-      body.should =~ /hello world/
+      expect(body).to match(/hello world/)
     end
 
     it "should connect only once when connected on start", :net_connect => true do
@@ -34,25 +34,25 @@ shared_examples_for "Net::HTTP" do
       }
 
       if !defined?(WebMock::Config) || WebMock::Config.instance.net_http_connect_on_start
-        socket_id_before_request.should_not == nil.object_id
-        socket_id_after_request.should_not == nil.object_id
-        socket_id_after_request.should == socket_id_before_request
+        expect(socket_id_before_request).not_to eq(nil.object_id)
+        expect(socket_id_after_request).not_to eq(nil.object_id)
+        expect(socket_id_after_request).to eq(socket_id_before_request)
       else
-        socket_id_before_request.should == nil.object_id
-        socket_id_after_request.should_not == nil.object_id
+        expect(socket_id_before_request).to eq(nil.object_id)
+        expect(socket_id_after_request).not_to eq(nil.object_id)
       end
     end
 
     describe "without start" do
       it "should close connection after a real request" do
         @http.get('/') { }
-        @http.should_not be_started
+        expect(@http).not_to be_started
       end
 
       it "should execute block exactly once" do
         times = 0
         @http.get('/') { times += 1 }
-        times.should == 1
+        expect(times).to eq(1)
       end
 
       it "should have socket open during a real request" do
@@ -60,7 +60,7 @@ shared_examples_for "Net::HTTP" do
         @http.get('/') {
           socket_id = @http.instance_variable_get(:@socket).object_id
         }
-        socket_id.should_not be_nil
+        expect(socket_id).not_to be_nil
       end
 
       it "should be started during a real request" do
@@ -68,21 +68,21 @@ shared_examples_for "Net::HTTP" do
         @http.get('/') {
           started = @http.started?
         }
-        started.should == true
-        @http.started?.should == false
+        expect(started).to eq(true)
+        expect(@http.started?).to eq(false)
       end
     end
 
     describe "with start" do
       it "should close connection after a real request" do
         @http.start {|conn| conn.get('/') { } }
-        @http.should_not be_started
+        expect(@http).not_to be_started
       end
 
       it "should execute block exactly once" do
         times = 0
         @http.start {|conn| conn.get('/') { times += 1 }}
-        times.should == 1
+        expect(times).to eq(1)
       end
 
       it "should have socket open during a real request" do
@@ -91,7 +91,7 @@ shared_examples_for "Net::HTTP" do
             socket_id = conn.instance_variable_get(:@socket).object_id
           }
         }
-        socket_id.should_not be_nil
+        expect(socket_id).not_to be_nil
       end
 
       it "should be started during a real request" do
@@ -100,15 +100,15 @@ shared_examples_for "Net::HTTP" do
             started = conn.started?
           }
         }
-        started.should == true
-        @http.started?.should == false
+        expect(started).to eq(true)
+        expect(@http.started?).to eq(false)
       end
     end
 
     describe "with start without request block" do
       it "should close connection after a real request" do
         @http.start {|conn| conn.get('/') }
-        @http.should_not be_started
+        expect(@http).not_to be_started
       end
 
       it "should have socket open during a real request" do
@@ -116,7 +116,7 @@ shared_examples_for "Net::HTTP" do
         @http.start {|conn|
           socket_id = conn.instance_variable_get(:@socket).object_id
         }
-        socket_id.should_not be_nil
+        expect(socket_id).not_to be_nil
       end
 
       it "should be started during a real request" do
@@ -124,8 +124,8 @@ shared_examples_for "Net::HTTP" do
         @http.start {|conn|
           started = conn.started?
         }
-        started.should == true
-        @http.started?.should == false
+        expect(started).to eq(true)
+        expect(@http.started?).to eq(false)
       end
     end
 
@@ -133,9 +133,9 @@ shared_examples_for "Net::HTTP" do
       it "should gracefully start and close connection" do
         @http.start
         @http.get("/")
-        @http.should be_started
+        expect(@http).to be_started
         @http.finish
-        @http.should_not be_started
+        expect(@http).not_to be_started
       end
     end
   end

data/spec/acceptance/net_http/net_http_spec.rb

@@ -58,32 +58,32 @@ describe "Net:HTTP" do
 
   describe "constants" do
     it "should still have const Get defined on replaced Net::HTTP" do
-      Object.const_get("Net").const_get("HTTP").const_defined?("Get").should be_true
+      expect(Object.const_get("Net").const_get("HTTP").const_defined?("Get")).to be_truthy
     end
 
     it "should still have const Get within constants on replaced Net::HTTP" do
-      Object.const_get("Net").const_get("HTTP").constants.map(&:to_s).should include("Get")
+      expect(Object.const_get("Net").const_get("HTTP").constants.map(&:to_s)).to include("Get")
     end
 
     it "should still have const Get within constants on replaced Net::HTTP" do
-      Object.const_get("Net").const_get("HTTP").const_get("Get").should_not be_nil
+      expect(Object.const_get("Net").const_get("HTTP").const_get("Get")).not_to be_nil
     end
 
     if Module.method(:const_defined?).arity != 1
       it "should still have const Get defined (and not inherited) on replaced Net::HTTP" do
-        Object.const_get("Net").const_get("HTTP").const_defined?("Get", false).should be_true
+        expect(Object.const_get("Net").const_get("HTTP").const_defined?("Get", false)).to be_truthy
       end
     end
 
     if Module.method(:const_get).arity != 1
       it "should still be able to get non inherited constant Get on replaced Net::HTTP" do
-        Object.const_get("Net").const_get("HTTP").const_get("Get", false).should_not be_nil
+        expect(Object.const_get("Net").const_get("HTTP").const_get("Get", false)).not_to be_nil
       end
     end
 
     if Module.method(:constants).arity != 0
       it "should still Get within non inherited constants on replaced Net::HTTP" do
-        Object.const_get("Net").const_get("HTTP").constants(false).map(&:to_s).should include("Get")
+        expect(Object.const_get("Net").const_get("HTTP").constants(false).map(&:to_s)).to include("Get")
       end
     end
 
@@ -94,22 +94,22 @@ describe "Net:HTTP" do
       it "Net::HTTP should have the same constants" do
         orig_consts_number = WebMock::HttpLibAdapters::NetHttpAdapter::OriginalNetHTTP.constants.size
         Net::HTTP.send(:const_set, "TEST_CONST", 10)
-        Net::HTTP.constants.size.should == orig_consts_number + 1
+        expect(Net::HTTP.constants.size).to eq(orig_consts_number + 1)
         WebMock.disable!
-        Net::HTTP.constants.size.should == orig_consts_number + 1
+        expect(Net::HTTP.constants.size).to eq(orig_consts_number + 1)
       end
     end
   end
 
   it "should work with block provided" do
     stub_http_request(:get, "www.example.com").to_return(:body => "abc"*100000)
-    Net::HTTP.start("www.example.com") { |query| query.get("/") }.body.should == "abc"*100000
+    expect(Net::HTTP.start("www.example.com") { |query| query.get("/") }.body).to eq("abc"*100000)
   end
 
   it "should handle multiple values for the same response header" do
     stub_http_request(:get, "www.example.com").to_return(:headers => { 'Set-Cookie' => ['foo=bar', 'bar=bazz'] })
     response = Net::HTTP.get_response(URI.parse("http://www.example.com/"))
-    response.get_fields('Set-Cookie').should == ['bar=bazz', 'foo=bar']
+    expect(response.get_fields('Set-Cookie')).to eq(['bar=bazz', 'foo=bar'])
   end
 
   it "should yield block on response" do
@@ -118,49 +118,49 @@ describe "Net:HTTP" do
     http_request(:get, "http://www.example.com/") do |response|
       response_body = response.body
     end
-    response_body.should == "abc"
+    expect(response_body).to eq("abc")
   end
 
   it "should handle Net::HTTP::Post#body" do
     stub_http_request(:post, "www.example.com").with(:body => "my_params").to_return(:body => "abc")
     req = Net::HTTP::Post.new("/")
     req.body = "my_params"
-    Net::HTTP.start("www.example.com") { |http| http.request(req)}.body.should == "abc"
+    expect(Net::HTTP.start("www.example.com") { |http| http.request(req)}.body).to eq("abc")
   end
 
   it "should handle Net::HTTP::Post#body_stream" do
     stub_http_request(:post, "www.example.com").with(:body => "my_params").to_return(:body => "abc")
     req = Net::HTTP::Post.new("/")
     req.body_stream = StringIO.new("my_params")
-    Net::HTTP.start("www.example.com") { |http| http.request(req)}.body.should == "abc"
+    expect(Net::HTTP.start("www.example.com") { |http| http.request(req)}.body).to eq("abc")
   end
 
   it "should behave like Net::HTTP and raise error if both request body and body argument are set" do
     stub_http_request(:post, "www.example.com").with(:body => "my_params").to_return(:body => "abc")
     req = Net::HTTP::Post.new("/")
     req.body = "my_params"
-    lambda {
+    expect {
       Net::HTTP.start("www.example.com") { |http| http.request(req, "my_params")}
-    }.should raise_error("both of body argument and HTTPRequest#body set")
+    }.to raise_error("both of body argument and HTTPRequest#body set")
   end
 
   it "should return a Net::ReadAdapter from response.body when a stubbed request is made with a block and #read_body" do
     WebMock.stub_request(:get, 'http://example.com/').to_return(:body => "the body")
     response = Net::HTTP.new('example.com', 80).request_get('/') { |r| r.read_body { } }
-    response.body.should be_a(Net::ReadAdapter)
+    expect(response.body).to be_a(Net::ReadAdapter)
   end
 
   it "should have request 1 time executed in registry after 1 real request", :net_connect => true do
     WebMock.allow_net_connect!
     http = Net::HTTP.new('localhost', port)
     http.get('/') {}
-    WebMock::RequestRegistry.instance.requested_signatures.hash.size.should == 1
-    WebMock::RequestRegistry.instance.requested_signatures.hash.values.first.should == 1
+    expect(WebMock::RequestRegistry.instance.requested_signatures.hash.size).to eq(1)
+    expect(WebMock::RequestRegistry.instance.requested_signatures.hash.values.first).to eq(1)
   end
 
   it "should work with Addressable::URI passed to Net::HTTP.get_response" do
     stub_request(:get, 'http://www.example.com/hello?a=1').to_return(:body => "abc")
-    Net::HTTP.get_response(Addressable::URI.parse('http://www.example.com/hello?a=1')).body.should == "abc"
+    expect(Net::HTTP.get_response(Addressable::URI.parse('http://www.example.com/hello?a=1')).body).to eq("abc")
   end
 
   describe "connecting on Net::HTTP.start" do
@@ -173,7 +173,7 @@ describe "Net:HTTP" do
       it "should not connect to the server until the request", :net_connect => true do
         WebMock.allow_net_connect!
         @http.start {|conn|
-          conn.peer_cert.should be_nil
+          expect(conn.peer_cert).to be_nil
         }
       end
 
@@ -181,7 +181,7 @@ describe "Net:HTTP" do
         WebMock.allow_net_connect!(:net_http_connect_on_start => true)
         @http.start {|conn|
           cert = OpenSSL::X509::Certificate.new conn.peer_cert
-          cert.should be_a(OpenSSL::X509::Certificate)
+          expect(cert).to be_a(OpenSSL::X509::Certificate)
         }
       end
 
@@ -191,7 +191,7 @@ describe "Net:HTTP" do
       it "should not connect to the server until the request", :net_connect => true do
         WebMock.disable_net_connect!(:allow => "www.google.com")
         @http.start {|conn|
-          conn.peer_cert.should be_nil
+          expect(conn.peer_cert).to be_nil
         }
       end
 
@@ -199,7 +199,7 @@ describe "Net:HTTP" do
         WebMock.disable_net_connect!(:allow => "www.google.com", :net_http_connect_on_start => true)
         @http.start {|conn|
           cert = OpenSSL::X509::Certificate.new conn.peer_cert
-          cert.should be_a(OpenSSL::X509::Certificate)
+          expect(cert).to be_a(OpenSSL::X509::Certificate)
         }
       end
 
@@ -258,21 +258,21 @@ describe "Net:HTTP" do
       http_request(:get, "http://localhost:#{port}/") do |response|
         response.read_body { |fragment| response_body << fragment }
       end
-      response_body.should =~ expected_body_regex
+      expect(response_body).to match(expected_body_regex)
 
-      @callback_response.body.should == response_body
+      expect(@callback_response.body).to eq(response_body)
     end
 
     it "should support the after_request callback on a request with a returning block" do
       response_body = perform_get_with_returning_block
-      response_body.should =~ expected_body_regex
-      @callback_response.should be_instance_of(WebMock::Response)
-      @callback_response.body.should == response_body
+      expect(response_body).to match(expected_body_regex)
+      expect(@callback_response).to be_instance_of(WebMock::Response)
+      expect(@callback_response.body).to eq(response_body)
     end
 
     it "should only invoke the after_request callback once, even for a recursive post request" do
       Net::HTTP.new('localhost', port).post('/', nil)
-      @callback_invocation_count.should == 1
+      expect(@callback_invocation_count).to eq(1)
     end
   end
 end