Let TestResponse assign a parser.

Previously we'd only assign a response parser when a request came through
Action Dispatch integration tests. This made calls to `parsed_body` when a TestResponse
was manually instantiated — though own doing or perhaps from a framework — unintentionally
blow up because no parser was set at that time.

The response can lookup a parser entirely through its own ivars. Extract request encoder to
its own file and assume that a viable content type is present at TestResponse instantiation.

Since the default response parser is a no-op, making `parsed_body` equal to `body`, no
exceptions will be thrown.

actionpack/lib/action_dispatch/testing/integration.rb

@@ -6,6 +6,8 @@
 require 'rack/test'
 require 'minitest'
 
+require 'action_dispatch/testing/request_encoder'
+
 module ActionDispatch
   module Integration #:nodoc:
     module RequestHelpers
@@ -383,7 +385,6 @@ def process(method, path, params: nil, headers: nil, env: nil, xhr: false, as: n
           response = _mock_session.last_response
           @response = ActionDispatch::TestResponse.from_response(response)
           @response.request = @request
-          @response.response_parser = RequestEncoder.parser(@response.content_type)
           @html_document = nil
           @url_options = nil
 
@@ -402,59 +403,6 @@ def build_expanded_path(path, request_encoder)
           path = request_encoder.append_format_to location.path
           location.query ? "#{path}?#{location.query}" : path
         end
-
-        class RequestEncoder # :nodoc:
-          @encoders = {}
-
-          attr_reader :response_parser
-
-          def initialize(mime_name, param_encoder, response_parser, url_encoded_form = false)
-            @mime = Mime[mime_name]
-
-            unless @mime
-              raise ArgumentError, "Can't register a request encoder for " \
-                "unregistered MIME Type: #{mime_name}. See `Mime::Type.register`."
-            end
-
-            @url_encoded_form = url_encoded_form
-            @path_format      = ".#{@mime.symbol}" unless @url_encoded_form
-            @response_parser  = response_parser || -> body { body }
-            @param_encoder    = param_encoder   || :"to_#{@mime.symbol}".to_proc
-          end
-
-          def append_format_to(path)
-            if @url_encoded_form
-              path
-            else
-              path + @path_format
-            end
-          end
-
-          def content_type
-            @mime.to_s
-          end
-
-          def encode_params(params)
-            @param_encoder.call(params)
-          end
-
-          def self.parser(content_type)
-            mime = Mime::Type.lookup(content_type)
-            encoder(mime ? mime.ref : nil).response_parser
-          end
-
-          def self.encoder(name)
-            @encoders[name] || WWWFormEncoder
-          end
-
-          def self.register_encoder(mime_name, param_encoder: nil, response_parser: nil)
-            @encoders[mime_name] = new(mime_name, param_encoder, response_parser)
-          end
-
-          register_encoder :json, response_parser: -> body { JSON.parse(body) }
-
-          WWWFormEncoder = new(:url_encoded_form, -> params { params }, nil, true)
-        end
     end
 
     module Runner
@@ -777,7 +725,7 @@ def app=(app)
         end
 
         def register_encoder(*args)
-          Integration::Session::RequestEncoder.register_encoder(*args)
+          RequestEncoder.register_encoder(*args)
         end
       end
 

actionpack/lib/action_dispatch/testing/request_encoder.rb

+module ActionDispatch
+  class RequestEncoder # :nodoc:
+    @encoders = {}
+
+    attr_reader :response_parser
+
+    def initialize(mime_name, param_encoder, response_parser, url_encoded_form = false)
+      @mime = Mime[mime_name]
+
+      unless @mime
+        raise ArgumentError, "Can't register a request encoder for " \
+          "unregistered MIME Type: #{mime_name}. See `Mime::Type.register`."
+      end
+
+      @url_encoded_form = url_encoded_form
+      @path_format      = ".#{@mime.symbol}" unless @url_encoded_form
+      @response_parser  = response_parser || -> body { body }
+      @param_encoder    = param_encoder   || :"to_#{@mime.symbol}".to_proc
+    end
+
+    def append_format_to(path)
+      if @url_encoded_form
+        path
+      else
+        path + @path_format
+      end
+    end
+
+    def content_type
+      @mime.to_s
+    end
+
+    def encode_params(params)
+      @param_encoder.call(params)
+    end
+
+    def self.parser(content_type)
+      mime = Mime::Type.lookup(content_type)
+      encoder(mime ? mime.ref : nil).response_parser
+    end
+
+    def self.encoder(name)
+      @encoders[name] || WWWFormEncoder
+    end
+
+    def self.register_encoder(mime_name, param_encoder: nil, response_parser: nil)
+      @encoders[mime_name] = new(mime_name, param_encoder, response_parser)
+    end
+
+    register_encoder :json, response_parser: -> body { JSON.parse(body) }
+
+    WWWFormEncoder = new(:url_encoded_form, -> params { params }, nil, true)
+  end
+end

actionpack/lib/action_dispatch/testing/test_response.rb

+require 'action_dispatch/testing/request_encoder'
+
 module ActionDispatch
   # Integration test methods such as ActionDispatch::Integration::Session#get
   # and ActionDispatch::Integration::Session#post return objects of class
@@ -10,6 +12,11 @@ def self.from_response(response)
       new response.status, response.headers, response.body
     end
 
+    def initialize(*) # :nodoc:
+      super
+      @response_parser = RequestEncoder.parser(content_type)
+    end
+
     # Was the response successful?
     alias_method :success?, :successful?
 
@@ -19,8 +26,6 @@ def self.from_response(response)
     # Was there a server-side error?
     alias_method :error?, :server_error?
 
-    attr_writer :response_parser # :nodoc:
-
     def parsed_body
       @parsed_body ||= @response_parser.call(body)
     end

actionpack/test/dispatch/test_response_test.rb

@@ -17,4 +17,12 @@ def assert_response_code_range(range, predicate)
     assert_response_code_range 500..599, :server_error?
     assert_response_code_range 400..499, :client_error?
   end
+
+  test "response parsing" do
+    response = ActionDispatch::TestResponse.create(200, {}, '')
+    assert_equal response.body, response.parsed_body
+
+    response = ActionDispatch::TestResponse.create(200, { 'Content-Type' => 'application/json' }, '{ "foo": "fighters" }')
+    assert_equal({ 'foo' => 'fighters' }, response.parsed_body)
+  end
 end