webmock 3.0.1 → 3.18.1

data/spec/acceptance/httpclient/httpclient_spec.rb

@@ -31,6 +31,13 @@ describe "HTTPClient" do
     expect(response_body).to eq("abc")
   end
 
+  it "should not yield block on empty response if block provided" do
+    stub_request(:get, "www.example.com").to_return(body: "")
+    response_body = ""
+    http_request(:get, "http://www.example.com/"){ raise }
+    expect(response_body).to eq("")
+  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"]} )
     expect(http_request(
@@ -48,7 +55,7 @@ describe "HTTPClient" do
 
   it "should work with get_content" do
     stub_request(:get, 'www.example.com').to_return(status: 200, body: 'test', headers: {})
-    str = ''
+    str = ''.dup
     HTTPClient.get_content('www.example.com') do |content|
       str << content
     end

data/spec/acceptance/manticore/manticore_spec.rb

@@ -51,6 +51,57 @@ if RUBY_PLATFORM =~ /java/
         response = Manticore.head("http://example-foo.com")
         expect(response.code).to eq(204)
       end
+
+      context "when a custom failure handler is defined" do
+        let(:failure_handler) { proc {} }
+
+        before do
+          allow(failure_handler).to receive(:call).with(kind_of(Manticore::Timeout)) do |ex|
+            raise ex
+          end
+        end
+
+        it "handles timeouts by invoking the failure handler" do
+          stub_request(:get, "http://example-foo.com").to_timeout
+          request = Manticore.get("http://example-foo.com").tap do |req|
+            req.on_failure(&failure_handler)
+          end
+          expect { request.call }.to raise_error(Manticore::Timeout)
+          expect(failure_handler).to have_received(:call)
+        end
+      end
+
+      context 'when used in a streaming mode' do
+        let(:webmock_server_url) {"http://#{WebMockServer.instance.host_with_port}/"}
+        let(:result_chunks) { [] }
+
+        def manticore_streaming_get
+          Manticore.get(webmock_server_url).tap do |req|
+            req.on_success do |response|
+              response.body do |chunk|
+                result_chunks << chunk
+              end
+            end
+          end
+        end
+
+        context 'when connections are allowed' do
+          it 'works' do
+            WebMock.allow_net_connect!
+            expect { manticore_streaming_get.call }.to_not raise_error
+            expect(result_chunks).to_not be_empty
+          end
+        end
+
+        context 'when stubbed' do
+          it 'works' do
+            stub_body = 'hello!'
+            stub_request(:get, webmock_server_url).to_return(body: stub_body)
+            expect { manticore_streaming_get.call }.to_not raise_error
+            expect(result_chunks).to eq [stub_body]
+          end
+        end
+      end
     end
   end
 end

data/spec/acceptance/net_http/net_http_shared.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 shared_examples_for "Net::HTTP" do
   describe "when making real requests", net_connect: true do
     let(:port){ WebMockServer.instance.port }
@@ -12,7 +14,7 @@ shared_examples_for "Net::HTTP" do
     end
 
     it "should handle requests with block passed to read_body", net_connect: true do
-      body = ""
+      body = "".dup
       req = Net::HTTP::Get.new("/")
       Net::HTTP.start("localhost", port) do |http|
         http.request(req) do |res|
@@ -26,21 +28,56 @@ shared_examples_for "Net::HTTP" 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
+      socket_before_request = socket_after_request = nil
       @http.start {|conn|
-        socket_id_before_request = conn.instance_variable_get(:@socket).object_id
+        socket_before_request = conn.instance_variable_get(:@socket)
         conn.request(Net::HTTP::Get.new("/"))
-        socket_id_after_request = conn.instance_variable_get(:@socket).object_id
+        socket_after_request = conn.instance_variable_get(:@socket)
       }
 
-      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)
+      if !defined?(WebMock::NetHTTPUtility) || WebMock::Config.instance.net_http_connect_on_start
+        expect(socket_before_request).to be_a(Net::BufferedIO)
+        expect(socket_after_request).to be_a(Net::BufferedIO)
+        expect(socket_after_request).to be(socket_before_request)
+      else
+        expect(socket_before_request).to be_a(StubSocket)
+        expect(socket_after_request).to be_a(Net::BufferedIO)
+      end
+    end
+
+    it "should allow sending multiple requests when persisted", net_connect: true do
+      @http = Net::HTTP.new('example.org')
+      @http.start
+      expect(@http.get("/")).to be_a(Net::HTTPSuccess)
+      expect(@http.get("/")).to be_a(Net::HTTPSuccess)
+      expect(@http.get("/")).to be_a(Net::HTTPSuccess)
+      @http.finish
+    end
+
+    it "should not leak file descriptors", net_connect: true do
+      sockets = Set.new
+
+      @http = Net::HTTP.new('example.org')
+      @http.start
+      sockets << @http.instance_variable_get(:@socket)
+      @http.get("/")
+      sockets << @http.instance_variable_get(:@socket)
+      @http.get("/")
+      sockets << @http.instance_variable_get(:@socket)
+      @http.get("/")
+      sockets << @http.instance_variable_get(:@socket)
+      @http.finish
+
+      if !defined?(WebMock::NetHTTPUtility) || WebMock.net_http_connect_on_start?(Addressable::URI.parse("http://example.com/"))
+        expect(sockets.length).to eq(1)
+        expect(sockets.to_a[0]).to be_a(Net::BufferedIO)
       else
-        expect(socket_id_before_request).to eq(nil.object_id)
-        expect(socket_id_after_request).not_to eq(nil.object_id)
+        expect(sockets.length).to eq(2)
+        expect(sockets.to_a[0]).to be_a(StubSocket)
+        expect(sockets.to_a[1]).to be_a(Net::BufferedIO)
       end
+
+      expect(sockets.all?(&:closed?)).to be(true)
     end
 
     it "should pass the read_timeout value on", net_connect: true do

data/spec/acceptance/net_http/net_http_spec.rb

@@ -115,33 +115,16 @@ describe "Net:HTTP" do
     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
+  it "raises an ArgumentError if passed headers as symbols" do
     uri = URI.parse("http://google.com/")
     http = Net::HTTP.new(uri.host, uri.port)
     request = Net::HTTP::Get.new(uri.request_uri)
+    request[:InvalidHeaderSinceItsASymbol] = "this will not be valid"
 
-    # 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
+    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
 
   it "should handle multiple values for the same response header" do
@@ -201,6 +184,34 @@ describe "Net:HTTP" do
     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
+
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7.0')
+    it "uses the StubSocket to provide IP address" do
+      Net::HTTP.start("http://example.com") do |http|
+        expect(http.ipaddr).to eq("127.0.0.1")
+      end
+    end
+  end
+
+  it "defines common socket methods" do
+    Net::HTTP.start("http://example.com") do |http|
+      socket = http.instance_variable_get(:@socket)
+      expect(socket.io.ssl_version).to eq("TLSv1.3")
+      expect(socket.io.cipher).to eq(["TLS_AES_128_GCM_SHA256", "TLSv1.3", 128, 128])
+    end
+  end
+
   describe "connecting on Net::HTTP.start" do
     before(:each) do
       @http = Net::HTTP.new('www.google.com', 443)
@@ -242,6 +253,21 @@ describe "Net:HTTP" do
         }
       end
 
+      it "should connect to the server on start when allowlisted", net_connect: true do
+        WebMock.disable_net_connect!(allow: "www.google.com", net_http_connect_on_start: "www.google.com")
+        @http.start {|conn|
+          cert = OpenSSL::X509::Certificate.new conn.peer_cert
+          expect(cert).to be_a(OpenSSL::X509::Certificate)
+        }
+      end
+
+      it "should not connect to the server on start when not allowlisted", net_connect: true do
+        WebMock.disable_net_connect!(allow: "www.google.com", net_http_connect_on_start: "www.yahoo.com")
+        @http.start {|conn|
+          expect(conn.peer_cert).to be_nil
+        }
+      end
+
       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','/')
@@ -270,6 +296,13 @@ describe "Net:HTTP" do
     it_should_behave_like "Net::HTTP"
   end
 
+  describe "when net_http_connect_on_start is a specific host" do
+    before(:each) do
+      WebMock.allow_net_connect!(net_http_connect_on_start: "localhost")
+    end
+    it_should_behave_like "Net::HTTP"
+  end
+
   describe 'after_request callback support', net_connect: true do
     let(:expected_body_regex) { /hello world/ }
 
@@ -293,7 +326,7 @@ 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
@@ -314,4 +347,49 @@ describe "Net:HTTP" do
       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
+
+    it "does not require a path" do
+      net_http = Net::HTTP.new('www.example.com', 80)
+      expect(WebMock::NetHTTPUtility.get_uri(net_http)).to eq('http://www.example.com:80')
+    end
+  end
 end

data/spec/acceptance/net_http/real_net_http_spec.rb

@@ -17,4 +17,4 @@ describe "Real Net:HTTP without webmock", without_webmock: true do
   end
 
   it_should_behave_like "Net::HTTP"
-end
+end

data/spec/acceptance/patron/patron_spec.rb

@@ -19,6 +19,13 @@ unless RUBY_PLATFORM =~ /java/
         @sess.base_url = "http://www.example.com"
       end
 
+      it "should allow stubbing PATCH request with body" do
+        stub_request(:patch, "http://www.example.com/")
+          .with(body: "abc")
+
+        @sess.patch('/', "abc")
+      end
+
       describe "file requests" do
 
         before(:each) do
@@ -86,31 +93,29 @@ unless RUBY_PLATFORM =~ /java/
         @sess.copy("/abc", "/def")
       end
 
-      if /^1\.9/ === RUBY_VERSION
-        describe "handling encoding same way as patron" do
-          around(:each) do |example|
-            @encoding = Encoding.default_internal
-            Encoding.default_internal = "UTF-8"
-            example.run
-            Encoding.default_internal = @encoding
-          end
+      describe "handling encoding same way as patron" do
+        around(:each) do |example|
+          @encoding = Encoding.default_internal
+          Encoding.default_internal = "UTF-8"
+          example.run
+          Encoding.default_internal = @encoding
+        end
 
-          it "should not encode body with default encoding" do
-            stub_request(:get, "www.example.com").
-              to_return(body: "Øl")
+        it "should not encode body with default encoding" do
+          stub_request(:get, "www.example.com").
+            to_return(body: "Øl")
 
-            expect(@sess.get("").body.encoding).to eq(Encoding::ASCII_8BIT)
-            expect(@sess.get("").inspectable_body.encoding).to eq(Encoding::UTF_8)
-          end
+          expect(@sess.get("").body.encoding).to eq(Encoding::ASCII_8BIT)
+          expect(@sess.get("").inspectable_body.encoding).to eq(Encoding::UTF_8)
+        end
 
-          it "should not encode body to default internal" do
-            stub_request(:get, "www.example.com").
-              to_return(headers: {'Content-Type' => 'text/html; charset=iso-8859-1'},
-                        body: "Øl".encode("iso-8859-1"))
+        it "should not encode body to default internal" do
+          stub_request(:get, "www.example.com").
+            to_return(headers: {'Content-Type' => 'text/html; charset=iso-8859-1'},
+                      body: "Øl".encode("iso-8859-1"))
 
-            expect(@sess.get("").body.encoding).to eq(Encoding::ASCII_8BIT)
-            expect(@sess.get("").decoded_body.encoding).to eq(Encoding.default_internal)
-          end
+          expect(@sess.get("").body.encoding).to eq(Encoding::ASCII_8BIT)
+          expect(@sess.get("").decoded_body.encoding).to eq(Encoding.default_internal)
         end
       end
     end

data/spec/acceptance/patron/patron_spec_helper.rb

@@ -16,7 +16,7 @@ module PatronSpecHelper
     sess.timeout = 30
     sess.max_redirects = 0
     uri = "#{uri.path}#{uri.query ? '?' : ''}#{uri.query}"
-    uri.gsub!(' ','%20')
+    uri = uri.gsub(' ','%20')
     response = sess.request(method, uri, options[:headers] || {}, {
       data: options[:body]
     })
@@ -28,8 +28,8 @@ module PatronSpecHelper
       end
     end
 
-    status_line_pattern = %r(\AHTTP/(\d+\.\d+)\s+(\d\d\d)\s*([^\r\n]+)?)
-    message = response.status_line.match(status_line_pattern)[3] || ""
+    status_line_pattern = %r(\AHTTP/(\d+(\.\d+)?)\s+(\d\d\d)\s*([^\r\n]+)?)
+    message = response.status_line.match(status_line_pattern)[4] || ""
 
     OpenStruct.new({
       body: response.body,

data/spec/acceptance/shared/allowing_and_disabling_net_connect.rb

@@ -91,7 +91,7 @@ shared_context "allowing and disabling net connect" do |*adapter_info|
     describe "is not allowed, with exceptions" do
       describe "allowing by host string" do
         before :each do
-          WebMock.disable_net_connect!(allow: 'httpstat.us')
+          WebMock.disable_net_connect!(allow: 'https://httpstat.us')
         end
 
         context "when the host is not allowed" do
@@ -109,13 +109,13 @@ shared_context "allowing and disabling net connect" do |*adapter_info|
 
         context "when the host is allowed" do
           it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'httpstat.us/200').to_return(body: "abc")
-            expect(http_request(:get, "http://httpstat.us/200").body).to eq("abc")
+            stub_request(:get, 'https://httpstat.us/200').to_return(body: "abc")
+            expect(http_request(:get, "https://httpstat.us/200").body).to eq("abc")
           end
 
           # WARNING: this makes a real HTTP request!
           it "should make a real request to allowed host", net_connect: true do
-            expect(http_request(:get, "http://httpstat.us/200").status).to eq('200')
+            expect(http_request(:get, "https://httpstat.us/200").status).to eq('200')
           end
         end
       end
@@ -229,13 +229,13 @@ shared_context "allowing and disabling net connect" do |*adapter_info|
 
         context "when the host is allowed" do
           it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'httpstat.us/200').to_return(body: "abc")
-            expect(http_request(:get, "http://httpstat.us/200").body).to eq("abc")
+            stub_request(:get, 'https://httpstat.us/200').to_return(body: "abc")
+            expect(http_request(:get, "https://httpstat.us/200").body).to eq("abc")
           end
 
           # WARNING: this makes a real HTTP request!
           it "should make a real request to allowed host", net_connect: true do
-            expect(http_request(:get, "http://httpstat.us/200").status).to eq('200')
+            expect(http_request(:get, "https://httpstat.us/200").status).to eq('200')
           end
 
           it "should make a real request if request is allowed by path regexp and url contains default port", net_connect: true do
@@ -266,20 +266,20 @@ shared_context "allowing and disabling net connect" do |*adapter_info|
 
         context "when the host is allowed" do
           it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'httpstat.us/200').to_return(body: "abc")
-            expect(http_request(:get, "http://httpstat.us/200").body).to eq("abc")
+            stub_request(:get, 'https://httpstat.us/200').to_return(body: "abc")
+            expect(http_request(:get, "https://httpstat.us/200").body).to eq("abc")
           end
 
           # WARNING: this makes a real HTTP request!
           it "should make a real request to allowed host", net_connect: true do
-            expect(http_request(:get, "http://httpstat.us/200").status).to eq('200')
+            expect(http_request(:get, "https://httpstat.us/200").status).to eq('200')
           end
         end
       end
 
       describe "allowing by a list of the above" do
         before :each do
-          WebMock.disable_net_connect!(allow: [lambda{|_| false }, %r{foobar}, 'httpstat.us'])
+          WebMock.disable_net_connect!(allow: [lambda{|_| false }, %r{foobar}, 'https://httpstat.us'])
         end
 
         context "when the host is not allowed" do
@@ -297,13 +297,13 @@ shared_context "allowing and disabling net connect" do |*adapter_info|
 
         context "when the host is allowed" do
           it "should return stubbed response if request was stubbed" do
-            stub_request(:get, 'httpstat.us/200').to_return(body: "abc")
-            expect(http_request(:get, "http://httpstat.us/200").body).to eq("abc")
+            stub_request(:get, 'https://httpstat.us/200').to_return(body: "abc")
+            expect(http_request(:get, "https://httpstat.us/200").body).to eq("abc")
           end
 
           # WARNING: this makes a real HTTP request!
           it "should make a real request to allowed host", net_connect: true do
-            expect(http_request(:get, "http://httpstat.us/200").status).to eq('200')
+            expect(http_request(:get, "https://httpstat.us/200").status).to eq('200')
           end
         end
       end

data/spec/acceptance/shared/callbacks.rb

@@ -102,7 +102,7 @@ shared_context "callbacks" do |*adapter_info|
           WebMock.after_request(except: [:other_lib])  do |_, response|
             @response = response
           end
-          http_request(:get, "http://httpstat.us/201")
+          http_request(:get, "https://httpstat.us/201", headers: { "Accept" => "*" })
         end
 
         it "should pass real response to callback with status and message" do
@@ -111,7 +111,8 @@ shared_context "callbacks" do |*adapter_info|
         end
 
         it "should pass real response to callback with headers" do
-          expect(@response.headers["Content-Length"]).to eq("11")
+          expect(@response.headers["Server"]).to eq( "Kestrel")
+          expect(@response.headers["Content-Length"]).to eq("11") unless adapter_info.include?(:no_content_length_header)
         end
 
         it "should pass response to callback with body" do

data/spec/acceptance/shared/complex_cross_concern_behaviors.rb

@@ -18,7 +18,7 @@ shared_context "complex cross-concern behaviors" do |*adapter_info|
     expect(played_back_response).to eq(real_response)
   end
 
-  let(:no_content_url) { 'http://httpstat.us/204' }
+  let(:no_content_url) { 'https://httpstat.us/204' }
   [nil, ''].each do |stub_val|
     it "returns the same value (nil or "") for a request stubbed as #{stub_val.inspect} that a real empty response has", net_connect: true do
       unless http_library == :curb

data/spec/acceptance/shared/request_expectations.rb

@@ -165,6 +165,20 @@ shared_context "request expectations" do |*adapter_info|
             expect(a_request(:get, "www.example.com").with(query: hash_including({"a" => ["b", "c"]}))).to have_been_made
           }.not_to raise_error
         end
+
+        it 'should satisfy expectation if the request was executed with excluding part of query params declared as a hash in a query option' do
+          expect {
+            http_request(:get, "http://www.example.com/?a[]=d&b[]=e&b=1")
+            expect(a_request(:get, "www.example.com").with(query: hash_excluding(a: ['b', 'c']))).to have_been_made
+          }.not_to raise_error
+        end
+
+        it 'should satisfy expectation if the request was executed with an empty array in the query params' do
+          expect {
+            http_request(:get, "http://www.example.com/?a[]")
+            expect(a_request(:get, "www.example.com").with(query: hash_including(a: []))).to have_been_made
+          }.not_to raise_error
+        end
       end
 
       context "when using flat array notation" do

data/spec/acceptance/shared/returning_declared_responses.rb

@@ -64,7 +64,10 @@ shared_context "declared responses" do |*adapter_info|
     it "should return response with declared headers" do
       stub_request(:get, "www.example.com").to_return(headers: SAMPLE_HEADERS)
       response = http_request(:get, "http://www.example.com/")
-      expect(response.headers["Content-Length"]).to eq("8888")
+      expect(response.headers["Accept"]).to eq("application/json")
+      unless adapter_info.include?(:no_content_length_header)
+        expect(response.headers["Content-Length"]).to eq("8888")
+      end
     end
 
     it "should return response with declared headers even if there are multiple headers with the same key" do
@@ -171,13 +174,22 @@ shared_context "declared responses" do |*adapter_info|
       end
 
       it "should return recorded headers" do
-        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"
-        })
+        if adapter_info.include?(:no_content_length_header)
+          expect(@response.headers).to eq({
+            "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
+            "Content-Type"=>"text/html; charset=UTF-8",
+            "Connection"=>"Keep-Alive",
+            "Accept"=>"image/jpeg, image/png"
+          })
+        else
+          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
       end
 
       it "should return recorded body" do
@@ -205,13 +217,22 @@ shared_context "declared responses" do |*adapter_info|
       end
 
       it "should return recorded headers" do
-        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"
-        })
+        if adapter_info.include?(:no_content_length_header)
+          expect(@response.headers).to eq({
+            "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
+            "Content-Type"=>"text/html; charset=UTF-8",
+            "Connection"=>"Keep-Alive",
+            "Accept"=>"image/jpeg, image/png"
+          })
+        else
+          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
       end
 
       it "should return recorded body" do