webmock 3.14.0 → 3.18.1

data/spec/acceptance/async_http_client/async_http_client_spec.rb

@@ -248,7 +248,7 @@ unless RUBY_PLATFORM =~ /java/
     end
 
     context 'multiple requests' do
-      let(:endpoint) { Async::HTTP::Endpoint.parse('http://www.example.com') }
+      let!(:endpoint) { Async::HTTP::Endpoint.parse('http://www.example.com') }
       let(:requests_count) { 3 }
 
       shared_examples :common do
@@ -300,13 +300,13 @@ unless RUBY_PLATFORM =~ /java/
         end
 
         context 'HTTP1 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP1 }
+          let!(:protocol) { Async::HTTP::Protocol::HTTP1 }
 
           include_examples :common
         end
 
         context 'HTTP2 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP2 }
+          let!(:protocol) { Async::HTTP::Protocol::HTTP2 }
 
           include_examples :common
         end
@@ -331,13 +331,13 @@ unless RUBY_PLATFORM =~ /java/
         end
 
         context 'HTTP1 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP1 }
+          let!(:protocol) { Async::HTTP::Protocol::HTTP1 }
 
           include_examples :common
         end
 
         context 'HTTP2 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP2 }
+          let!(:protocol) { Async::HTTP::Protocol::HTTP2 }
 
           include_examples :common
         end

data/spec/acceptance/curb/curb_spec.rb

@@ -383,6 +383,17 @@ unless RUBY_PLATFORM =~ /java/
         expect(c.body).to eq("abc")
       end
 
+      it "supports headers containing the ':' character" do
+        stub_request(:get, "www.example.com").with(headers: {'Referer'=>'http://www.example.com'}).to_return(body: "abc")
+
+        c = Curl::Easy.new
+        c.url = "http://www.example.com"
+        c.headers = ["Referer: http://www.example.com"]
+        c.http(:GET)
+        expect(c.body).to eq("abc")
+        expect(c.headers).to eq(["Referer: http://www.example.com"])
+      end
+
       describe 'match request body' do
         it 'for post' do
           stub_request(:post, "www.example.com").with(body: 'foo=nhe').to_return(body: "abc")

data/spec/acceptance/em_http_request/em_http_request_spec.rb

@@ -22,7 +22,7 @@ unless RUBY_PLATFORM =~ /java/
 
         def make_request
           EM.run do
-            request = EM::HttpRequest.new(http_url).get(redirects: 1)
+            request = EM::HttpRequest.new(http_url, ssl: {verify_peer: true}).get(redirects: 1)
             request.callback { EM.stop }
           end
         end

data/spec/acceptance/em_http_request/em_http_request_spec_helper.rb

@@ -16,7 +16,7 @@ module EMHttpRequestSpecHelper
     error_set = false
     uri = Addressable::URI.heuristic_parse(uri)
     EventMachine.run {
-      request = EventMachine::HttpRequest.new("#{uri.normalize.to_s}")
+      request = EventMachine::HttpRequest.new("#{uri.normalize.to_s}", ssl: {verify_peer: true})
       http = request.send(method, {
         timeout: 30,
         body: options[:body],

data/spec/acceptance/excon/excon_spec.rb

@@ -20,7 +20,7 @@ describe "Excon" do
     it "should support excon response_block for real requests", net_connect: true do
       a = []
       WebMock.allow_net_connect!
-      r = Excon.new('http://httpstat.us/200', headers: { "Accept" => "*" }).
+      r = Excon.new('https://httpstat.us/200', headers: { "Accept" => "*" }).
         get(response_block: lambda {|e, remaining, total| a << e}, chunk_size: 1)
       expect(a).to eq(["2", "0", "0", " ", "O", "K"])
       expect(r.body).to eq("")
@@ -41,7 +41,7 @@ describe "Excon" do
       WebMock.after_request { |_, res|
         response = res
       }
-      r = Excon.new('http://httpstat.us/200', headers: { "Accept" => "*" }).
+      r = Excon.new('https://httpstat.us/200', headers: { "Accept" => "*" }).
         get(response_block: lambda {|e, remaining, total| a << e}, chunk_size: 1)
       expect(response.body).to eq("200 OK")
       expect(a).to eq(["2", "0", "0", " ", "O", "K"])

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 }
@@ -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
@@ -213,6 +196,22 @@ describe "Net:HTTP" do
     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)
@@ -254,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','/')
@@ -282,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/ }
 
@@ -365,5 +386,10 @@ describe "Net:HTTP" do
       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

@@ -93,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/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", headers: { "Accept" => "*" })
+          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,7 @@ shared_context "callbacks" do |*adapter_info|
         end
 
         it "should pass real response to callback with headers" do
-          expect(@response.headers["X-Powered-By"]).to eq( "ASP.NET")
+          expect(@response.headers["Server"]).to eq( "Kestrel")
           expect(@response.headers["Content-Length"]).to eq("11") unless adapter_info.include?(:no_content_length_header)
         end
 

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/unit/request_pattern_spec.rb

@@ -547,6 +547,18 @@ describe WebMock::RequestPattern do
                                                            body: "{\"a\":\"1\",\"b\":\"five\",\"c\":{\"d\":[\"e\",\"f\"]}}"))
                 end
 
+            it "should match if the request body has a top level array" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: [{a: 1}])).
+                to match(WebMock::RequestSignature.new(:post, "www.example.com",
+                headers: {content_type: content_type}, body: "[{\"a\":1}]"))
+            end
+
+            it "should not match if the request body has a different top level array" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: ["a", "b"])).
+                not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
+                headers: {content_type: content_type}, body: "[\"a\", \"c\"]"))
+            end
+
             it "should not match when body is not json" do
               expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
                 not_to match(WebMock::RequestSignature.new(:post, "www.example.com",

data/spec/unit/request_signature_spec.rb

@@ -18,7 +18,7 @@ describe WebMock::RequestSignature do
     end
 
     it "assigns normalized headers" do
-      expect(WebMock::Util::Headers).to receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
+      allow(WebMock::Util::Headers).to receive(:normalize_headers).with({'A' => 'a'}.freeze).and_return('B' => 'b')
       expect(
         WebMock::RequestSignature.new(:get, "www.example.com", headers: {'A' => 'a'}).headers
       ).to eq({'B' => 'b'})
@@ -125,11 +125,21 @@ describe WebMock::RequestSignature do
       expect(subject.url_encoded?).to be true
     end
 
+    it "returns true if the headers are urlencoded with a specified charset" do
+      subject.headers = { "Content-Type" => "application/x-www-form-urlencoded; charset=UTF-8" }
+      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 content type header is present" do
+      subject.headers = { "Some-Header" => "some-value" }
+      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
@@ -142,11 +152,21 @@ describe WebMock::RequestSignature do
       expect(subject.json_headers?).to be true
     end
 
+    it "returns true if the headers are json with a specified charset" do
+      subject.headers = { "Content-Type" => "application/json; charset=UTF-8" }
+      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 content type header is present" do
+      subject.headers = { "Some-Header" => "some-value" }
+      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

data/spec/unit/request_stub_spec.rb

@@ -50,6 +50,41 @@ describe WebMock::RequestStub do
 
   end
 
+  describe "to_return_json" do
+
+    it "should raise if a block is given" do
+      expect {
+        @request_stub.to_return_json(body: "abc", status: 500) { puts "don't call me" }
+      }.to raise_error(ArgumentError, '#to_return_json does not support passing a block')
+    end
+
+    it "should assign responses normally" do
+      @request_stub.to_return_json([{body: "abc"}, {body: "def"}])
+      expect([@request_stub.response.body, @request_stub.response.body]).to eq(["abc", "def"])
+    end
+
+    it "should json-ify a Hash body" do
+      @request_stub.to_return_json(body: {abc: "def"}, status: 500)
+      expect(@request_stub.response.body).to eq({abc: "def"}.to_json)
+      expect(@request_stub.response.status).to eq([500, ""])
+    end
+
+    it "should apply the content_type header" do
+      @request_stub.to_return_json(body: {abc: "def"}, status: 500)
+      expect(@request_stub.response.headers).to eq({"Content-Type"=>"application/json"})
+    end
+
+    it "should preserve existing headers" do
+      @request_stub.to_return_json(headers: {"A" => "a"}, body: "")
+      expect(@request_stub.response.headers).to eq({"A"=>"a", "Content-Type"=>"application/json"})
+    end
+
+    it "should allow callsites to override content_type header" do
+      @request_stub.to_return_json(headers: {content_type: 'application/super-special-json'})
+      expect(@request_stub.response.headers).to eq({"Content-Type"=>"application/super-special-json"})
+    end
+  end
+
   describe "then" do
     it "should return stub without any modifications, acting as syntactic sugar" do
       expect(@request_stub.then).to eq(@request_stub)

data/spec/unit/response_spec.rb

@@ -31,7 +31,7 @@ describe WebMock::Response do
   end
 
   it "should report normalized headers" do
-    expect(WebMock::Util::Headers).to receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
+    allow(WebMock::Util::Headers).to receive(:normalize_headers).with({'A' => 'a'}.freeze).and_return('B' => 'b')
     @response = WebMock::Response.new(headers: {'A' => 'a'})
     expect(@response.headers).to eq({'B' => 'b'})
   end
@@ -142,6 +142,34 @@ describe WebMock::Response do
   end
 
   describe "from raw response" do
+    describe "when input is a StringIO" do
+      before(:each) do
+        @io = StringIO.new(File.read(CURL_EXAMPLE_OUTPUT_PATH))
+        @response = WebMock::Response.new(@io)
+      end
+
+      it "should read status" do
+        expect(@response.status).to eq([202, "OK"])
+      end
+
+      it "should read 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"
+        )
+      end
+
+      it "should read body" do
+        expect(@response.body.size).to eq(419)
+      end
+
+      it "should close IO" do
+        expect(@io).to be_closed
+      end
+    end
 
     describe "when input is IO" do
       before(:each) do