webmock 1.8.6 → 3.14.0

data/spec/acceptance/net_http/net_http_shared.rb

@@ -1,18 +1,18 @@
 shared_examples_for "Net::HTTP" do
-  describe "when making real requests", :net_connect => true do
+  describe "when making real requests", net_connect: true do
     let(:port){ WebMockServer.instance.port }
 
     before(:each) do
       @http = Net::HTTP.new("localhost", port)
     end
 
-    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
+    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
-      body = ""
+    it "should handle requests with block passed to read_body", net_connect: true do
+      body = "".dup
       req = Net::HTTP::Get.new("/")
       Net::HTTP.start("localhost", port) do |http|
         http.request(req) do |res|
@@ -21,10 +21,10 @@ 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
+    it "should connect only once when connected on start", net_connect: true do
       @http = Net::HTTP.new('localhost', port)
       socket_id_before_request = socket_id_after_request = nil
       @http.start {|conn|
@@ -32,20 +32,38 @@ shared_examples_for "Net::HTTP" do
         conn.request(Net::HTTP::Get.new("/"))
         socket_id_after_request = conn.instance_variable_get(:@socket).object_id
       }
-      socket_id_after_request.should_not be_nil
-      socket_id_after_request.should == socket_id_before_request
+
+      if !defined?(WebMock::Config) || WebMock::Config.instance.net_http_connect_on_start
+        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
+        expect(socket_id_before_request).to eq(nil.object_id)
+        expect(socket_id_after_request).not_to eq(nil.object_id)
+      end
+    end
+
+    it "should pass the read_timeout value on", net_connect: true do
+      @http = Net::HTTP.new('localhost', port)
+      read_timeout = @http.read_timeout + 1
+      @http.read_timeout = read_timeout
+      @http.start {|conn|
+        conn.request(Net::HTTP::Get.new("/"))
+        socket = conn.instance_variable_get(:@socket)
+        expect(socket.read_timeout).to eq(read_timeout)
+      }
     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
@@ -53,7 +71,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
@@ -61,21 +79,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
@@ -84,7 +102,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
@@ -93,15 +111,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
@@ -109,7 +127,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
@@ -117,9 +135,19 @@ 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
+
+    describe "with start without a block and finish" do
+      it "should gracefully start and close connection" do
+        @http.start
+        @http.get("/")
+        expect(@http).to be_started
+        @http.finish
+        expect(@http).not_to be_started
       end
     end
   end
-end
+end

data/spec/acceptance/net_http/net_http_spec.rb

@@ -7,9 +7,9 @@ require 'acceptance/net_http/net_http_shared'
 include NetHTTPSpecHelper
 
 describe "Net:HTTP" do
-  include_examples "with WebMock"
+  include_examples "with WebMock", :no_url_auth
 
-  let(:port){ WebMockServer.instance.port }
+  let(:port) { WebMockServer.instance.port }
 
   describe "marshalling" do
     class TestMarshalingInWebMockNetHTTP
@@ -58,91 +58,159 @@ 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
+
+    describe "after WebMock is disabled" do
+      after(:each) do
+        WebMock.enable!
+      end
+      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)
+        expect(Net::HTTP.constants.size).to eq(orig_consts_number + 1)
+        WebMock.disable!
+        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
+    stub_http_request(:get, "www.example.com").to_return(body: "abc"*100000)
+    expect(Net::HTTP.start("www.example.com") { |query| query.get("/") }.body).to eq("abc"*100000)
+  end
+
+  it "should handle requests with raw binary data" do
+    body = "\x14\x00\x00\x00\x70\x69\x6e\x67\x00\x00"
+    stub_http_request(:post, "www.example.com").with(body: body).to_return(body: "abc")
+    req = Net::HTTP::Post.new("/")
+    req.body = body
+    req.content_type = "application/octet-stream"
+    expect(Net::HTTP.start("www.example.com") { |http| http.request(req)}.body).to eq("abc")
+  end
+
+  it "raises an ArgumentError if passed headers as symbols if RUBY_VERSION < 2.3.0" do
+    uri = URI.parse("http://google.com/")
+    http = Net::HTTP.new(uri.host, uri.port)
+    request = Net::HTTP::Get.new(uri.request_uri)
+
+    # Net::HTTP calls downcase on header keys assigned with []=
+    # In Ruby 1.8.7 symbols do not respond to downcase
+    #
+    # Meaning you can not assign header keys as symbols in ruby 1.8.7 using []=
+    if :symbol.respond_to?(:downcase)
+      request[:InvalidHeaderSinceItsASymbol] = "this will not be valid"
+    else
+      request.instance_eval do
+        @header = request.to_hash.merge({InvalidHeaderSinceItsASymbol: "this will not be valid"})
+      end
+    end
+
+    if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('2.3.0')
+      expect do
+        http.request(request)
+      end.to raise_error ArgumentError, "Net:HTTP does not accept headers as symbols"
+    else
+      stub_http_request(:get, "google.com").with(headers: { InvalidHeaderSinceItsASymbol: "this will not be valid" })
+      expect do
+        http.request(request)
+      end.not_to raise_error
+    end
   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'] })
+    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
-    stub_http_request(:get, "www.example.com").to_return(:body => "abc")
+    stub_http_request(:get, "www.example.com").to_return(body: "abc")
     response_body = ""
     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")
+    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")
+    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")
+    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")
+    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
+  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")
+    expect(Net::HTTP.get_response(Addressable::URI.parse('http://www.example.com/hello?a=1')).body).to eq("abc")
+  end
+
+  it "should support method calls on stubbed socket" do
+    WebMock.allow_net_connect!
+    stub_request(:get, 'www.google.com')#.with(headers: {"My-Header" => 99})
+    req = Net::HTTP::Get.new('/')
+    Net::HTTP.start('www.google.com') do |http|
+      http.request(req, '')
+      socket = http.instance_variable_get(:@socket)
+      expect(socket).to be_a(StubSocket)
+      expect { socket.io.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) }.to_not raise_error
+    end
   end
 
   describe "connecting on Net::HTTP.start" do
@@ -151,43 +219,49 @@ describe "Net:HTTP" do
       @http.use_ssl = true
       @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
     end
+
     describe "when net http is allowed" do
-      it "should not connect to the server until the request", :net_connect => true 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
 
-      it "should connect to the server on start", :net_connect => true do
-        WebMock.allow_net_connect!(:net_http_connect_on_start => true)
+      it "should connect to the server on start", net_connect: true 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
 
     end
 
     describe "when net http is disabled and allowed only for some hosts" do
-      it "should not connect to the server until the request", :net_connect => true do
-        WebMock.disable_net_connect!(:allow => "www.google.com")
+      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
 
-      it "should connect to the server on start", :net_connect => true do
-        WebMock.disable_net_connect!(:allow => "www.google.com", :net_http_connect_on_start => true)
+      it "should connect to the server on start", net_connect: true 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
 
-      it "should connect to the server if the URI matches an regex", :net_connect => true do
-        WebMock.disable_net_connect!(:allow => /google.com/)
-        response = Net::HTTP.get('www.google.com','/')
+      it "should connect to the server if the URI matches an regex", net_connect: true do
+        WebMock.disable_net_connect!(allow: /google.com/)
+        Net::HTTP.get('www.google.com','/')
+      end
+
+      it "should connect to the server if the URI matches any regex the array", net_connect: true do
+        WebMock.disable_net_connect!(allow: [/google.com/, /yahoo.com/])
+        Net::HTTP.get('www.google.com','/')
       end
 
     end
@@ -196,19 +270,19 @@ describe "Net:HTTP" do
 
   describe "when net_http_connect_on_start is true" do
     before(:each) do
-      WebMock.allow_net_connect!(:net_http_connect_on_start => true)
+      WebMock.allow_net_connect!(net_http_connect_on_start: true)
     end
     it_should_behave_like "Net::HTTP"
   end
 
   describe "when net_http_connect_on_start is false" do
     before(:each) do
-      WebMock.allow_net_connect!(:net_http_connect_on_start => false)
+      WebMock.allow_net_connect!(net_http_connect_on_start: false)
     end
     it_should_behave_like "Net::HTTP"
   end
 
-  describe 'after_request callback support', :net_connect => true do
+  describe 'after_request callback support', net_connect: true do
     let(:expected_body_regex) { /hello world/ }
 
     before(:each) do
@@ -231,25 +305,65 @@ describe "Net:HTTP" do
     end
 
     it "should support the after_request callback on an request with block and read_body" do
-      response_body = ''
+      response_body = ''.dup
       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
+
+  it "should match http headers, even if their values have been set in a request as numbers" do
+    WebMock.disable_net_connect!
+
+    stub_request(:post, "www.example.com").with(headers: {"My-Header" => 99})
+
+    uri = URI.parse('http://www.example.com/')
+    req = Net::HTTP::Post.new(uri.path)
+    req['My-Header'] = 99
+
+    res = Net::HTTP.start(uri.host, uri.port) do |http|
+      http.request(req, '')
+    end
+  end
+
+  describe "hostname handling" do
+    it "should set brackets around the hostname if it is an IPv6 address" do
+      net_http = Net::HTTP.new('b2dc:5bdf:4f0d::3014:e0ca', 80)
+      path = '/example.jpg'
+      expect(WebMock::NetHTTPUtility.get_uri(net_http, path)).to eq('http://[b2dc:5bdf:4f0d::3014:e0ca]:80/example.jpg')
+    end
+
+    it "should not set brackets around the hostname if it is already wrapped by brackets" do
+      net_http = Net::HTTP.new('[b2dc:5bdf:4f0d::3014:e0ca]', 80)
+      path = '/example.jpg'
+      expect(WebMock::NetHTTPUtility.get_uri(net_http, path)).to eq('http://[b2dc:5bdf:4f0d::3014:e0ca]:80/example.jpg')
+    end
+
+    it "should not set brackets around the hostname if it is an IPv4 address" do
+      net_http = Net::HTTP.new('181.152.137.168', 80)
+      path = '/example.jpg'
+      expect(WebMock::NetHTTPUtility.get_uri(net_http, path)).to eq('http://181.152.137.168:80/example.jpg')
+    end
+
+    it "should not set brackets around the hostname if it is a domain" do
+      net_http = Net::HTTP.new('www.example.com', 80)
+      path = '/example.jpg'
+      expect(WebMock::NetHTTPUtility.get_uri(net_http, path)).to eq('http://www.example.com:80/example.jpg')
     end
   end
 end

data/spec/acceptance/net_http/net_http_spec_helper.rb

@@ -10,15 +10,18 @@ module NetHTTPSpecHelper
     req = clazz.new("#{uri.path}#{uri.query ? '?' : ''}#{uri.query}", nil)
     options[:headers].each do |k,v|
       if v.is_a?(Array)
-        v.each_with_index do |v,i|
-          i == 0 ? (req[k] = v) : req.add_field(k, v)
+        v.each_with_index do |e,i|
+          i == 0 ? (req[k] = e) : req.add_field(k, e)
         end
       else
         req[k] = v
       end
     end if options[:headers]
 
-    req.basic_auth uri.user, uri.password if uri.user
+    if options[:basic_auth]
+      req.basic_auth(options[:basic_auth][0], options[:basic_auth][1])
+    end
+
     http = Net::HTTP.new(uri.host, uri.port)
     if uri.scheme == "https"
       http.use_ssl = true
@@ -28,21 +31,27 @@ module NetHTTPSpecHelper
       http.read_timeout = 60
     end
     http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    response = http.start {|http|
-      http.request(req, options[:body], &block)
+    response = http.start {|open_http|
+      open_http.request(req, options[:body], &block)
     }
     headers = {}
     response.each_header {|name, value| headers[name] = value}
     OpenStruct.new({
-      :body => response.body,
-      :headers => WebMock::Util::Headers.normalize_headers(headers),
-      :status => response.code,
-      :message => response.message
+      body: response.body,
+      headers: WebMock::Util::Headers.normalize_headers(headers),
+      status: response.code,
+      message: response.message
     })
   end
 
   def client_timeout_exception_class
-    Timeout::Error
+    if defined?(Net::OpenTimeout)
+      Net::OpenTimeout
+    elsif defined?(Net::HTTP::OpenTimeout)
+      Net::HTTP::OpenTimeout
+    else
+      Timeout::Error
+    end
   end
 
   def connection_refused_exception_class

data/spec/acceptance/net_http/real_net_http_spec.rb

@@ -6,7 +6,7 @@ require 'stringio'
 require 'acceptance/net_http/net_http_shared'
 require 'support/webmock_server'
 
-describe "Real Net:HTTP without webmock", :without_webmock => true do
+describe "Real Net:HTTP without webmock", without_webmock: true do
   before(:all) do
     raise "WebMock has no access here!!!" if defined?(WebMock::NetHTTPUtility)
     WebMockServer.instance.start