puppet 4.10.0 → 5.0.0

data/spec/unit/network/http/compression_spec.rb

@@ -2,6 +2,20 @@
 require 'spec_helper'
 
 describe "http compression" do
+  let(:data)            { "uncompresseddata" }
+  let(:response)        { stub 'response' }
+  let(:compressed_zlib) { Zlib::Deflate.deflate(data) }
+  let(:compressed_gzip) do
+    str = StringIO.new
+    writer = Zlib::GzipWriter.new(str)
+    writer.write(data)
+    writer.close.string
+  end
+
+  def stubs_response_with(response, content_encoding, body)
+    response.stubs(:[]).with('content-encoding').returns(content_encoding)
+    response.stubs(:body).returns(body)
+  end
 
   describe "when zlib is not available" do
     before(:each) do
@@ -24,8 +38,8 @@ describe "http compression" do
     end
 
     it "should not tamper the body" do
-      response = stub 'response', :body => "data"
-      expect(@uncompressor.uncompress_body(response)).to eq("data")
+      response = stub 'response', :body => data
+      expect(@uncompressor.uncompress_body(response)).to eq(data)
     end
 
     it "should yield an identity uncompressor" do
@@ -37,23 +51,19 @@ describe "http compression" do
   end
 
   describe "when zlib is available" do
-    before(:each) do
-      Puppet.features.stubs(:zlib?).returns true
-
-      require 'puppet/network/http/compression'
-      class HttpUncompressor
-        include Puppet::Network::HTTP::Compression::Active
-      end
-
-      @uncompressor = HttpUncompressor.new
+    require 'puppet/network/http/compression'
+    class ActiveUncompressor
+      include Puppet::Network::HTTP::Compression::Active
     end
 
+    let(:uncompressor) { ActiveUncompressor.new }
+
     it "should have a module function that returns the Active underlying module" do
       expect(Puppet::Network::HTTP::Compression.module).to eq(Puppet::Network::HTTP::Compression::Active)
     end
 
     it "should add an Accept-Encoding header supporting compression" do
-      headers = @uncompressor.add_accept_encoding({})
+      headers = uncompressor.add_accept_encoding({})
       expect(headers).to have_key('accept-encoding')
       expect(headers['accept-encoding']).to match(/gzip/)
       expect(headers['accept-encoding']).to match(/deflate/)
@@ -61,43 +71,34 @@ describe "http compression" do
     end
 
     describe "when uncompressing response body" do
-      before do
-        @response = stub 'response'
-        @response.stubs(:[]).with('content-encoding')
-        @response.stubs(:body).returns("mydata")
-      end
+      context "without compression" do
+        it "should return untransformed response body with no content-encoding" do
+          stubs_response_with(response, nil, data)
 
-      it "should return untransformed response body with no content-encoding" do
-        expect(@uncompressor.uncompress_body(@response)).to eq("mydata")
-      end
+          expect(uncompressor.uncompress_body(response)).to eq(data)
+        end
+
+        it "should return untransformed response body with 'identity' content-encoding" do
+          stubs_response_with(response, 'identity', data)
 
-      it "should return untransformed response body with 'identity' content-encoding" do
-        @response.stubs(:[]).with('content-encoding').returns('identity')
-        expect(@uncompressor.uncompress_body(@response)).to eq("mydata")
+          expect(uncompressor.uncompress_body(response)).to eq(data)
+        end
       end
 
-      it "should use a Zlib inflater with 'deflate' content-encoding" do
-        @response.stubs(:[]).with('content-encoding').returns('deflate')
+      context "with 'zlib' content-encoding" do
+        it "should use a Zlib inflater" do
+          stubs_response_with(response, 'deflate', compressed_zlib)
 
-        inflater = stub 'inflater'
-        Zlib::Inflate.expects(:new).returns(inflater)
-        inflater.expects(:inflate).with("mydata").returns "uncompresseddata"
+          expect(uncompressor.uncompress_body(response)).to eq(data)
+        end
 
-        expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
       end
 
       context "with 'gzip' content-encoding" do
         it "should use a GzipReader" do
-          @response.stubs(:[]).with('content-encoding').returns('gzip')
+          stubs_response_with(response, 'gzip', compressed_gzip)
 
-          io = stub 'io'
-          StringIO.expects(:new).with("mydata").returns io
-
-          reader = stub 'gzip reader'
-          Zlib::GzipReader.expects(:new).with(io, :encoding => Encoding::BINARY).returns(reader)
-          reader.expects(:read).returns "uncompresseddata"
-
-          expect(@uncompressor.uncompress_body(@response)).to eq("uncompresseddata")
+          expect(uncompressor.uncompress_body(response)).to eq(data)
         end
 
         it "should correctly decompress PSON containing UTF-8 in Binary Encoding" do
@@ -117,10 +118,9 @@ describe "http compression" do
             default_external = Encoding.default_external
             Encoding.default_external = Encoding::ISO_8859_1
 
-            @response.stubs(:[]).with('content-encoding').returns('gzip')
-            @response.stubs(:body).returns(compressed_body)
+            stubs_response_with(response, 'gzip', compressed_body)
 
-            uncompressed = @uncompressor.uncompress_body(@response)
+            uncompressed = uncompressor.uncompress_body(response)
             # By default Zlib::GzipReader decompresses into Encoding.default_external, and we want to ensure our result is BINARY too
             expect(uncompressed.encoding).to eq(Encoding::BINARY)
             expect(uncompressed).to eq("\"foo\xDB\xBF\xE1\x9A\xA0\xF0\xA0\x9C\x8E\"".force_encoding(Encoding::BINARY))
@@ -132,89 +132,106 @@ describe "http compression" do
     end
 
     describe "when uncompressing by chunk" do
-      before do
-        @response = stub 'response'
-        @response.stubs(:[]).with('content-encoding')
+      it "should yield an identity uncompressor with no content-encoding" do
+        stubs_response_with(response, nil, data)
 
-        @inflater = stub_everything 'inflater'
-        Zlib::Inflate.stubs(:new).returns(@inflater)
+        expect { |b|
+          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::IdentityAdapter, &b)
+        }
       end
 
-      it "should yield an identity uncompressor with no content-encoding" do
-        @uncompressor.uncompress(@response) { |u|
-          expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
+      it "should yield an identity uncompressor with 'identity' content-encoding" do
+        stubs_response_with(response, 'identity', data)
+
+        expect { |b|
+          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::IdentityAdapter, &b)
         }
       end
 
-      it "should yield an identity uncompressor with 'identity' content-encoding" do
-        @response.stubs(:[]).with('content-encoding').returns 'identity'
-        @uncompressor.uncompress(@response) { |u|
-          expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
+      it "should yield a Zlib uncompressor with 'gzip' content-encoding" do
+        stubs_response_with(response, 'gzip', compressed_gzip)
+
+        expect { |b|
+          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::ZlibAdapter, &b)
         }
       end
 
-      %w{gzip deflate}.each do |c|
-        it "should yield a Zlib uncompressor with '#{c}' content-encoding" do
-          @response.stubs(:[]).with('content-encoding').returns c
-          @uncompressor.uncompress(@response) { |u|
-            expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::Active::ZlibAdapter)
-          }
-        end
+      it "should yield a Zlib uncompressor with 'deflate' content-encoding" do
+        stubs_response_with(response, 'deflate', compressed_zlib)
+
+        expect { |b|
+          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::ZlibAdapter, &b)
+        }
       end
 
       it "should close the underlying adapter" do
+        stubs_response_with(response, 'identity', data)
         adapter = stub_everything 'adapter'
         Puppet::Network::HTTP::Compression::IdentityAdapter.expects(:new).returns(adapter)
 
         adapter.expects(:close)
-        @uncompressor.uncompress(@response) { |u| }
+        uncompressor.uncompress(response) { |u| }
       end
-    end
 
-    describe "zlib adapter" do
-      before do
-        @inflater = stub_everything 'inflater'
-        Zlib::Inflate.stubs(:new).returns(@inflater)
-        @adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
+      it "should close the underlying adapter if the yielded block raises" do
+        stubs_response_with(response, 'identity', data)
+        adapter = stub_everything 'adapter'
+        Puppet::Network::HTTP::Compression::IdentityAdapter.expects(:new).returns(adapter)
+
+        adapter.expects(:close)
+        expect {
+          uncompressor.uncompress(response) { |u| raise ArgumentError, "whoops" }
+        }.to raise_error(ArgumentError, "whoops")
       end
+    end
 
+    describe "zlib adapter" do
       it "should initialize the underlying inflater with gzip/zlib header parsing" do
         Zlib::Inflate.expects(:new).with(15+32)
+
         Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
       end
 
-      it "should inflate the given chunk" do
-        @inflater.expects(:inflate).with("chunk")
-        @adapter.uncompress("chunk")
-      end
+      it "should return the given chunk" do
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
 
-      it "should return the inflated chunk" do
-        @inflater.stubs(:inflate).with("chunk").returns("uncompressed")
-        expect(@adapter.uncompress("chunk")).to eq("uncompressed")
+        expect(adapter.uncompress(compressed_zlib)).to eq(data)
       end
 
       it "should try a 'regular' inflater on Zlib::DataError" do
-        @inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
-        inflater = stub_everything 'inflater2'
-        inflater.expects(:inflate).with("chunk").returns("uncompressed")
-        Zlib::Inflate.expects(:new).with.returns(inflater)
-        @adapter.uncompress("chunk")
+        inflater = Zlib::Inflate.new(15 + 32)
+        inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
+
+        expect(adapter.uncompress(compressed_zlib)).to eq(data)
       end
 
       it "should raise the error the second time" do
-        @inflater.stubs(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
-        Zlib::Inflate.expects(:new).with.returns(@inflater)
-        expect { @adapter.uncompress("chunk") }.to raise_error(Zlib::DataError, /not a zlib stream/)
+        inflater = Zlib::Inflate.new(15 + 32)
+        inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
+
+        expect { adapter.uncompress("this is not compressed data") }.to raise_error(Zlib::DataError, /incorrect header check/)
       end
 
-      it "should finish the stream on close" do
-        @inflater.expects(:finish)
-        @adapter.close
+      it "should finish and close the stream" do
+        inflater = stub 'inflater'
+        inflater.expects(:finish)
+        inflater.expects(:close)
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
+
+        adapter.close
       end
 
-      it "should close the stream on close" do
-        @inflater.expects(:close)
-        @adapter.close
+      it "should close the stream even if finish raises" do
+        inflater = stub 'inflater'
+        inflater.expects(:finish).raises(Zlib::BufError)
+        inflater.expects(:close)
+
+        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
+        expect {
+          adapter.close
+        }.to raise_error(Zlib::BufError)
       end
     end
   end

data/spec/unit/network/http/error_spec.rb

@@ -15,7 +15,7 @@ describe Puppet::Network::HTTP::Error do
   end
 
   describe Puppet::Network::HTTP::Error::HTTPServerError do
-    it "should serialize to JSON that matches the error schema and has a deprecated stacktrace property" do
+    it "should serialize to JSON that matches the error schema" do
       begin
         raise Exception, "a wild Exception appeared!"
       rescue Exception => e
@@ -24,7 +24,6 @@ describe Puppet::Network::HTTP::Error do
       error = Puppet::Network::HTTP::Error::HTTPServerError.new(culpable)
 
       expect(error.to_json).to validate_against('api/schemas/error.json')
-      expect(error.to_json).to match(/The 'stacktrace' property is deprecated/)
     end
   end
 

data/spec/unit/network/http/handler_spec.rb

@@ -18,8 +18,8 @@ describe Puppet::Network::HTTP::Handler do
 
   def a_request(method = "HEAD", path = "/production/#{indirection.name}/unknown")
     {
-      :accept_header => "pson",
-      :content_type_header => "text/pson",
+      :accept_header => "application/json",
+      :content_type_header => "application/json",
       :method => method,
       :path => path,
       :params => {},
@@ -68,7 +68,7 @@ describe Puppet::Network::HTTP::Handler do
 
       res_body = JSON(res[:body])
 
-      expect(res[:content_type_header]).to eq("application/json")
+      expect(res[:content_type_header]).to eq("application/json; charset=utf-8")
       expect(res_body["issue_kind"]).to eq("HANDLER_NOT_FOUND")
       expect(res_body["message"]).to eq("Not Found: No route for GET /vtest/foo")
       expect(res[:status]).to eq(404)
@@ -92,12 +92,9 @@ describe Puppet::Network::HTTP::Handler do
 
       res_body = JSON(res[:body])
 
-      expect(res[:content_type_header]).to eq("application/json")
+      expect(res[:content_type_header]).to eq("application/json; charset=utf-8")
       expect(res_body["issue_kind"]).to eq(Puppet::Network::HTTP::Issues::RUNTIME_ERROR.to_s)
       expect(res_body["message"]).to eq("Server Error: the sky is falling!")
-      expect(res_body["stacktrace"].is_a?(Array) && !res_body["stacktrace"].empty?).to be_truthy
-      expect(res_body["stacktrace"][0]).to match(/The 'stacktrace' property is deprecated/)
-      expect(res_body["stacktrace"] & original_stacktrace).to be_empty
       expect(res[:status]).to eq(500)
     end
 
@@ -142,16 +139,16 @@ describe Puppet::Network::HTTP::Handler do
     it "should still find the correct format if content type contains charset information" do
       request = Puppet::Network::HTTP::Request.new({ 'content-type' => "text/plain; charset=UTF-8" },
                                                    {}, 'GET', '/', nil)
-      expect(request.format).to eq("s")
+      expect(request.formatter.name).to eq(:s)
     end
 
     # PUP-3272
     # This used to be for YAML, and doing a to_yaml on an array.
-    # The result with to_pson is something different, the result is a string
+    # The result with to_json is something different, the result is a string
     # Which seems correct. Looks like this was some kind of nesting option "yaml inside yaml" ?
     # Removing the test
-#    it "should deserialize PSON parameters" do
-#      params = {'my_param' => [1,2,3].to_pson}
+#    it "should deserialize JSON parameters" do
+#      params = {'my_param' => [1,2,3].to_json}
 #
 #      decoded_params = handler.send(:decode_params, params)
 #
@@ -159,7 +156,6 @@ describe Puppet::Network::HTTP::Handler do
 #    end
   end
 
-
   describe "when resolving node" do
     it "should use a look-up from the ip address" do
       Resolv.expects(:getname).with("1.2.3.4").returns("host.domain.com")

data/spec/unit/network/http/rack/rest_spec.rb

@@ -67,7 +67,7 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
 
       it "should return the unescaped path for an escaped request path" do
         unescaped_path = '/foo/bar baz'
-        escaped_path = URI.escape(unescaped_path)
+        escaped_path = Puppet::Util.uri_encode(unescaped_path)
         req = mk_req(escaped_path)
         expect(@handler.path(req)).to eq(unescaped_path)
       end
@@ -170,7 +170,7 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
       end
 
       it "should CGI-decode the HTTP parameters" do
-        encoding = CGI.escape("foo bar")
+        encoding = Puppet::Util.uri_query_encode("foo bar")
         req = mk_req("/?foo=#{encoding}")
         result = @handler.params(req)
         expect(result[:foo]).to eq("foo bar")
@@ -201,7 +201,7 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
       end
 
       it "should treat YAML encoded parameters like it was any string" do
-        escaping = CGI.escape(YAML.dump(%w{one two}))
+        escaping = Puppet::Util.uri_query_encode(YAML.dump(%w{one two}))
         req = mk_req("/?foo=#{escaping}")
         expect(@handler.params(req)[:foo]).to eq("---\n- one\n- two\n")
       end

data/spec/unit/network/http/request_spec.rb

@@ -0,0 +1,110 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'puppet_spec/network'
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::Request do
+  include PuppetSpec::Network
+
+  let(:json_formatter) { Puppet::Network::FormatHandler.format(:json) }
+  let(:pson_formatter) { Puppet::Network::FormatHandler.format(:pson) }
+
+  def headers
+    {
+      'accept' => 'application/json',
+      'content-type' => 'application/json'
+    }
+  end
+
+  def a_request(headers, body = "")
+    described_class.from_hash(
+      :method => "PUT",
+      :path   => "/path/to/endpoint",
+      :body   => body,
+      :headers => headers
+    )
+  end
+
+  context "when resolving the formatter for the request body" do
+    it "returns the formatter for that Content-Type" do
+      request = a_request(headers.merge("content-type" => "application/json"))
+      expect(request.formatter).to eq(json_formatter)
+    end
+
+    it "raises HTTP 400 if Content-Type is missing" do
+      request = a_request({})
+      expect {
+        request.formatter
+      }.to raise_error(bad_request_error, /No Content-Type header was received, it isn't possible to unserialize the request/)
+    end
+
+    it "raises HTTP 415 if Content-Type is unsupported" do
+      request = a_request(headers.merge('content-type' => 'application/ogg'))
+      expect {
+        request.formatter
+      }.to raise_error(unsupported_media_type_error, /Unsupported Media Type: Client sent a mime-type \(application\/ogg\) that doesn't correspond to a format we support/)
+    end
+
+    it "raises HTTP 415 if Content-Type is unsafe yaml" do
+      request = a_request(headers.merge('content-type' => 'yaml'))
+      expect {
+        request.formatter
+      }.to raise_error(unsupported_media_type_error, /Unsupported Media Type: Client sent a mime-type \(yaml\) that doesn't correspond to a format we support/)
+    end
+
+    it "raises HTTP 415 if Content-Type is unsafe b64_zlib_yaml" do
+      request = a_request(headers.merge('content-type' => 'b64_zlib_yaml'))
+      expect {
+        request.formatter
+      }.to raise_error(unsupported_media_type_error, /Unsupported Media Type: Client sent a mime-type \(b64_zlib_yaml\) that doesn't correspond to a format we support/)
+    end
+  end
+
+  context "when resolving the formatter for the response body" do
+    context "when the client doesn't specify an Accept header" do
+      it "raises HTTP 400 if the server doesn't specify a default" do
+        request = a_request({})
+        expect {
+          request.response_formatters_for([:json])
+        }.to raise_error(bad_request_error, /Missing required Accept header/)
+      end
+
+      it "uses the server default" do
+        request = a_request({})
+        expect(request.response_formatters_for([:json], 'application/json')).to eq([json_formatter])
+      end
+    end
+
+    it "returns accepted and supported formats, in the accepted order" do
+      request = a_request(headers.merge('accept' => 'application/json, application/x-msgpack, text/pson'))
+      expect(request.response_formatters_for([:pson, :json])).to eq([json_formatter, pson_formatter])
+    end
+
+    it "selects the second format if the first one isn't supported by the server" do
+      request = a_request(headers.merge('accept' => 'application/json, text/pson'))
+      expect(request.response_formatters_for([:pson])).to eq([pson_formatter])
+    end
+
+    it "raises HTTP 406 if Accept doesn't include any server-supported formats" do
+      request = a_request(headers.merge('accept' => 'application/ogg'))
+      expect {
+        request.response_formatters_for([:json])
+      }.to raise_error(not_acceptable_error, /No supported formats are acceptable \(Accept: application\/ogg\)/)
+    end
+
+    it "raises HTTP 406 if Accept resolves to unsafe yaml" do
+      request = a_request(headers.merge('accept' => 'yaml'))
+      expect {
+        request.response_formatters_for([:json])
+      }.to raise_error(not_acceptable_error, /No supported formats are acceptable \(Accept: yaml\)/)
+    end
+
+    it "raises HTTP 406 if Accept resolves to unsafe b64_zlib_yaml" do
+      request = a_request(headers.merge('accept' => 'b64_zlib_yaml'))
+      expect {
+        request.response_formatters_for([:json])
+      }.to raise_error(not_acceptable_error, /No supported formats are acceptable \(Accept: b64_zlib_yaml\)/)
+    end
+  end
+end

data/spec/unit/network/http/response_spec.rb

@@ -0,0 +1,108 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet_spec/handler'
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::Response do
+  include PuppetSpec::Files
+
+  let(:handler) { PuppetSpec::Handler.new }
+  let(:response) { {} }
+  let(:subject) { described_class.new(handler, response) }
+  let(:body_utf8) { JSON.dump({ "foo" => "bar"}).encode('UTF-8') }
+  let(:body_shift_jis) { [130, 174].pack('C*').force_encoding(Encoding::Shift_JIS) }
+  let(:invalid_shift_jis) { "\xC0\xFF".force_encoding(Encoding::Shift_JIS) }
+
+  context "when passed a response body" do
+    it "passes the status code and body to the handler" do
+      handler.expects(:set_response).with(response, body_utf8, 200)
+
+      subject.respond_with(200, 'application/json', body_utf8)
+    end
+
+    it "accepts a File body" do
+      file = tmpfile('response_spec')
+      handler.expects(:set_response).with(response, file, 200)
+
+      subject.respond_with(200, 'application/octet-stream', file)
+    end
+  end
+
+  context "when passed a content type" do
+    it "accepts a mime string" do
+      handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+
+      subject.respond_with(200, 'application/json', body_utf8)
+    end
+
+    it "accepts a format object" do
+      formatter = Puppet::Network::FormatHandler.format(:json)
+      handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+
+      subject.respond_with(200, formatter, body_utf8)
+    end
+  end
+
+  context "when resolving charset" do
+    context "with binary content" do
+      it "omits the charset" do
+        body_binary = [0xDEADCAFE].pack('L')
+
+        formatter = Puppet::Network::FormatHandler.format(:binary)
+        handler.expects(:set_content_type).with(response, 'application/octet-stream')
+
+        subject.respond_with(200, formatter, body_binary)
+      end
+    end
+
+    context "with text/plain content" do
+      let(:formatter) { Puppet::Network::FormatHandler.format(:s) }
+
+      it "sets the charset to UTF-8 for content already in that format" do
+        body_pem = "BEGIN CERTIFICATE".encode('UTF-8')
+
+        handler.expects(:set_content_type).with(response, 'text/plain; charset=utf-8')
+
+        subject.respond_with(200, formatter, body_pem)
+      end
+
+      it "encodes the content to UTF-8 for content not already in UTF-8" do
+        handler.expects(:set_content_type).with(response, 'text/plain; charset=utf-8')
+        handler.expects(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
+
+        subject.respond_with(200, formatter, body_shift_jis)
+      end
+
+      it "raises an exception if transcoding fails" do
+        expect {
+          subject.respond_with(200, formatter, invalid_shift_jis)
+        }.to raise_error(EncodingError, /"\\xFF" on Shift_JIS/)
+      end
+    end
+
+    context "with application/json content" do
+      let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
+
+      it "sets the charset to UTF-8 for content already in that format" do
+        handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+
+        subject.respond_with(200, formatter, body_utf8)
+      end
+
+      it "encodes the content to UTF-8 for content not already in UTF-8" do
+        handler.expects(:set_content_type).with(response, 'application/json; charset=utf-8')
+        handler.expects(:set_response).with(response, body_shift_jis.encode('utf-8'), 200)
+
+        subject.respond_with(200, formatter, body_shift_jis)
+      end
+
+      it "raises an exception if transcoding fails" do
+        expect {
+          subject.respond_with(200, formatter, invalid_shift_jis)
+        }.to raise_error(EncodingError, /"\\xFF" on Shift_JIS/)
+      end
+    end
+  end
+end