actionpack 6.1.7.5 → 7.1.3.1

data/lib/action_dispatch/system_testing/test_helpers/screenshot_helper.rb

@@ -13,42 +13,45 @@ module ActionDispatch
         # to investigate changes at different points during your test. These will be
         # named with a sequential prefix (or 'failed' for failing tests)
         #
-        # The screenshot will be displayed in your console, if supported.
+        # The default screenshots directory is +tmp/screenshots+ but you can set a different
+        # one with +Capybara.save_path+
         #
-        # You can set the +RAILS_SYSTEM_TESTING_SCREENSHOT_HTML+ environment variable to
-        # save the HTML from the page that is being screenhoted so you can investigate the
-        # elements on the page at the time of the screenshot
+        # You can use the +html+ argument or set the +RAILS_SYSTEM_TESTING_SCREENSHOT_HTML+
+        # environment variable to save the HTML from the page that is being screenshotted
+        # so you can investigate the elements on the page at the time of the screenshot
         #
-        # You can set the +RAILS_SYSTEM_TESTING_SCREENSHOT+ environment variable to
-        # control the output. Possible values are:
+        # You can use the +screenshot+ argument or set the +RAILS_SYSTEM_TESTING_SCREENSHOT+
+        # environment variable to control the output. Possible values are:
         # * [+simple+ (default)]    Only displays the screenshot path.
         #                           This is the default value.
         # * [+inline+]              Display the screenshot in the terminal using the
         #                           iTerm image protocol (https://iterm2.com/documentation-images.html).
         # * [+artifact+]            Display the screenshot in the terminal, using the terminal
         #                           artifact format (https://buildkite.github.io/terminal-to-html/inline-images/).
-        def take_screenshot
+        def take_screenshot(html: false, screenshot: nil)
+          showing_html = html || html_from_env?
+
           increment_unique
-          save_html if save_html?
+          save_html if showing_html
           save_image
-          puts display_image
+          show display_image(html: showing_html, screenshot_output: screenshot)
         end
 
         # Takes a screenshot of the current page in the browser if the test
         # failed.
         #
-        # +take_failed_screenshot+ is included in <tt>application_system_test_case.rb</tt>
-        # that is generated with the application. To take screenshots when a test
-        # fails add +take_failed_screenshot+ to the teardown block before clearing
-        # sessions.
+        # +take_failed_screenshot+ is called during system test teardown.
         def take_failed_screenshot
-          take_screenshot if failed? && supports_screenshot?
+          return unless failed? && supports_screenshot? && Capybara::Session.instance_created?
+
+          take_screenshot
+          metadata[:failure_screenshot_path] = relative_image_path if Minitest::Runnable.method_defined?(:metadata)
         end
 
         private
           attr_accessor :_screenshot_counter
 
-          def save_html?
+          def html_from_env?
             ENV["RAILS_SYSTEM_TESTING_SCREENSHOT_HTML"] == "1"
           end
 
@@ -62,7 +65,7 @@ module ActionDispatch
           end
 
           def image_name
-            sanitized_method_name = method_name.tr("/\\", "--")
+            sanitized_method_name = method_name.gsub(/[^\w]+/, "-")
             name = "#{unique}_#{sanitized_method_name}"
             name[0...225]
           end
@@ -76,13 +79,21 @@ module ActionDispatch
           end
 
           def absolute_path
-            Rails.root.join("tmp/screenshots/#{image_name}")
+            Rails.root.join(screenshots_dir, image_name)
+          end
+
+          def screenshots_dir
+            Capybara.save_path.presence || "tmp/screenshots"
           end
 
           def absolute_image_path
             "#{absolute_path}.png"
           end
 
+          def relative_image_path
+            "#{absolute_path.relative_path_from(Rails.root)}.png"
+          end
+
           def absolute_html_path
             "#{absolute_path}.html"
           end
@@ -105,11 +116,15 @@ module ActionDispatch
             output_type
           end
 
-          def display_image
+          def show(img)
+            puts img
+          end
+
+          def display_image(html:, screenshot_output:)
             message = +"[Screenshot Image]: #{image_path}\n"
-            message << +"[Screenshot HTML]: #{html_path}\n" if save_html?
+            message << +"[Screenshot HTML]: #{html_path}\n" if html
 
-            case output_type
+            case screenshot_output || output_type
             when "artifact"
               message << "\e]1338;url=artifact://#{absolute_image_path}\a\n"
             when "inline"

data/lib/action_dispatch/system_testing/test_helpers/setup_and_teardown.rb

@@ -4,14 +4,6 @@ module ActionDispatch
   module SystemTesting
     module TestHelpers
       module SetupAndTeardown # :nodoc:
-        def host!(host)
-          ActiveSupport::Deprecation.warn \
-            "ActionDispatch::SystemTestCase#host! is deprecated with no replacement. " \
-            "Set Capybara.app_host directly or rely on Capybara's default host."
-
-          Capybara.app_host = host
-        end
-
         def before_teardown
           take_failed_screenshot
         ensure

data/lib/action_dispatch/testing/assertion_response.rb

@@ -36,7 +36,7 @@ module ActionDispatch
 
     private
       def code_from_name(name)
-        GENERIC_RESPONSE_CODES[name] || Rack::Utils::SYMBOL_TO_STATUS_CODE[name]
+        GENERIC_RESPONSE_CODES[name] || Rack::Utils.status_code(name)
       end
 
       def name_from_code(code)

data/lib/action_dispatch/testing/assertions/response.rb

@@ -20,7 +20,7 @@ module ActionDispatch
       #
       # You can also pass an explicit status number like <tt>assert_response(501)</tt>
       # or its symbolic equivalent <tt>assert_response(:not_implemented)</tt>.
-      # See Rack::Utils::SYMBOL_TO_STATUS_CODE for a full list.
+      # See +Rack::Utils::SYMBOL_TO_STATUS_CODE+ for a full list.
       #
       #   # Asserts that the response was a redirection
       #   assert_response :redirect
@@ -30,7 +30,7 @@ module ActionDispatch
       def assert_response(type, message = nil)
         message ||= generate_response_message(type)
 
-        if RESPONSE_PREDICATES.keys.include?(type)
+        if RESPONSE_PREDICATES.key?(type)
           assert @response.public_send(RESPONSE_PREDICATES[type]), message
         else
           assert_equal AssertionResponse.new(type).code, @response.response_code, message
@@ -50,12 +50,19 @@ module ActionDispatch
       #
       #   # Asserts that the redirection matches the regular expression
       #   assert_redirected_to %r(\Ahttp://example.org)
-      def assert_redirected_to(options = {}, message = nil)
-        assert_response(:redirect, message)
-        return true if options === @response.location
+      #
+      #   # Asserts that the redirection has the HTTP status code 301 (Moved
+      #   # Permanently).
+      #   assert_redirected_to "/some/path", status: :moved_permanently
+      def assert_redirected_to(url_options = {}, options = {}, message = nil)
+        options, message = {}, options unless options.is_a?(Hash)
+
+        status = options[:status] || :redirect
+        assert_response(status, message)
+        return true if url_options === @response.location
 
         redirect_is       = normalize_argument_to_redirection(@response.location)
-        redirect_expected = normalize_argument_to_redirection(options)
+        redirect_expected = normalize_argument_to_redirection(url_options)
 
         message ||= "Expected response to be a redirect to <#{redirect_expected}> but was a redirect to <#{redirect_is}>"
         assert_operator redirect_expected, :===, redirect_is, message
@@ -93,7 +100,7 @@ module ActionDispatch
         end
 
         def code_with_name(code_or_name)
-          if RESPONSE_PREDICATES.values.include?("#{code_or_name}?".to_sym)
+          if RESPONSE_PREDICATES.value?("#{code_or_name}?".to_sym)
             code_or_name = RESPONSE_PREDICATES.invert["#{code_or_name}?".to_sym]
           end
 

data/lib/action_dispatch/testing/assertions/routing.rb

@@ -9,6 +9,36 @@ module ActionDispatch
   module Assertions
     # Suite of assertions to test routes generated by \Rails and the handling of requests made to them.
     module RoutingAssertions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # A helper to make it easier to test different route configurations.
+        # This method temporarily replaces @routes with a new RouteSet instance
+        # before each test.
+        #
+        # The new instance is yielded to the passed block. Typically the block
+        # will create some routes using <tt>set.draw { match ... }</tt>:
+        #
+        #   with_routing do |set|
+        #     set.draw do
+        #       resources :users
+        #     end
+        #   end
+        #
+        def with_routing(&block)
+          old_routes, old_controller = nil
+
+          setup do
+            old_routes, old_controller = @routes, @controller
+            create_routes(&block)
+          end
+
+          teardown do
+            reset_routes(old_routes, old_controller)
+          end
+        end
+      end
+
       def setup # :nodoc:
         @routes ||= nil
         super
@@ -18,8 +48,8 @@ module ActionDispatch
       # match +path+. Basically, it asserts that \Rails recognizes the route given by +expected_options+.
       #
       # Pass a hash in the second argument (+path+) to specify the request method. This is useful for routes
-      # requiring a specific HTTP method. The hash should contain a :path with the incoming request path
-      # and a :method containing the required HTTP verb.
+      # requiring a specific HTTP method. The hash should contain a +:path+ with the incoming request path
+      # and a +:method+ containing the required HTTP verb.
       #
       #   # Asserts that POSTing to /items will call the create action on ItemsController
       #   assert_recognizes({controller: 'items', action: 'create'}, {path: 'items', method: :post})
@@ -83,7 +113,7 @@ module ActionDispatch
       #   # Asserts that the generated route gives us our custom route
       #   assert_generates "changesets/12", { controller: 'scm', action: 'show_diff', revision: "12" }
       def assert_generates(expected_path, options, defaults = {}, extras = {}, message = nil)
-        if %r{://}.match?(expected_path)
+        if expected_path.include?("://")
           fail_on(URI::InvalidURIError, message) do
             uri = URI.parse(expected_path)
             expected_path = uri.path.to_s.empty? ? "/" : uri.path
@@ -150,33 +180,11 @@ module ActionDispatch
       #     assert_equal "/users", users_path
       #   end
       #
-      def with_routing
-        old_routes, @routes = @routes, ActionDispatch::Routing::RouteSet.new
-        if defined?(@controller) && @controller
-          old_controller, @controller = @controller, @controller.clone
-          _routes = @routes
-
-          @controller.singleton_class.include(_routes.url_helpers)
-
-          if @controller.respond_to? :view_context_class
-            view_context_class = Class.new(@controller.view_context_class) do
-              include _routes.url_helpers
-            end
-
-            custom_view_context = Module.new {
-              define_method(:view_context_class) do
-                view_context_class
-              end
-            }
-            @controller.extend(custom_view_context)
-          end
-        end
-        yield @routes
+      def with_routing(&block)
+        old_routes, old_controller = @routes, @controller
+        create_routes(&block)
       ensure
-        @routes = old_routes
-        if defined?(@controller) && @controller
-          @controller = old_controller
-        end
+        reset_routes(old_routes, old_controller)
       end
 
       # ROUTES TODO: These assertions should really work in an integration context
@@ -187,8 +195,40 @@ module ActionDispatch
           super
         end
       end
+      ruby2_keywords(:method_missing)
 
       private
+        def create_routes
+          @routes = ActionDispatch::Routing::RouteSet.new
+          if defined?(@controller) && @controller
+            @controller = @controller.clone
+            _routes = @routes
+
+            @controller.singleton_class.include(_routes.url_helpers)
+
+            if @controller.respond_to? :view_context_class
+              view_context_class = Class.new(@controller.view_context_class) do
+                include _routes.url_helpers
+              end
+
+              custom_view_context = Module.new {
+                define_method(:view_context_class) do
+                  view_context_class
+                end
+              }
+              @controller.extend(custom_view_context)
+            end
+          end
+          yield @routes
+        end
+
+        def reset_routes(old_routes, old_controller)
+          @routes = old_routes
+          if defined?(@controller) && @controller
+            @controller = old_controller
+          end
+        end
+
         # Recognizes the route for a given path.
         def recognized_request_for(path, extras = {}, msg)
           if path.is_a?(Hash)
@@ -201,7 +241,7 @@ module ActionDispatch
           controller = @controller if defined?(@controller)
           request = ActionController::TestRequest.create controller&.class
 
-          if %r{://}.match?(path)
+          if path.include?("://")
             fail_on(URI::InvalidURIError, msg) do
               uri = URI.parse(path)
               request.env["rack.url_scheme"] = uri.scheme || "http"

data/lib/action_dispatch/testing/assertions.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
 require "rails-dom-testing"
+require "action_dispatch/testing/assertions/response"
+require "action_dispatch/testing/assertions/routing"
 
 module ActionDispatch
   module Assertions
-    autoload :ResponseAssertions, "action_dispatch/testing/assertions/response"
-    autoload :RoutingAssertions, "action_dispatch/testing/assertions/routing"
-
     extend ActiveSupport::Concern
 
     include ResponseAssertions
@@ -17,7 +16,7 @@ module ActionDispatch
       @html_document ||= if @response.media_type&.end_with?("xml")
         Nokogiri::XML::Document.parse(@response.body)
       else
-        Nokogiri::HTML::Document.parse(@response.body)
+        Rails::Dom::Testing.html_document.parse(@response.body)
       end
     end
   end

data/lib/action_dispatch/testing/integration.rb

@@ -3,12 +3,12 @@
 require "stringio"
 require "uri"
 require "rack/test"
-require "minitest"
+require "active_support/test_case"
 
 require "action_dispatch/testing/request_encoder"
 
 module ActionDispatch
-  module Integration #:nodoc:
+  module Integration # :nodoc:
     module RequestHelpers
       # Performs a GET request with the given parameters. See ActionDispatch::Integration::Session#process
       # for more details.
@@ -58,7 +58,9 @@ module ActionDispatch
       # the same HTTP verb will be used when redirecting, otherwise a GET request
       # will be performed. Any arguments are passed to the
       # underlying request.
-      def follow_redirect!(**args)
+      #
+      # The HTTP_REFERER header will be set to the previous url.
+      def follow_redirect!(headers: {}, **args)
         raise "not a redirect! #{status} #{status_message}" unless redirect?
 
         method =
@@ -68,7 +70,11 @@ module ActionDispatch
             :get
           end
 
-        public_send(method, response.location, **args)
+        if [ :HTTP_REFERER, "HTTP_REFERER" ].none? { |key| headers.key? key }
+          headers["HTTP_REFERER"] = request.url
+        end
+
+        public_send(method, response.location, headers: headers, **args)
         status
       end
     end
@@ -78,9 +84,8 @@ module ActionDispatch
     # multiple sessions and run them side-by-side, you can also mimic (to some
     # limited extent) multiple simultaneous users interacting with your system.
     #
-    # Typically, you will instantiate a new session using
-    # IntegrationTest#open_session, rather than instantiating
-    # Integration::Session directly.
+    # Typically, you will instantiate a new session using Runner#open_session,
+    # rather than instantiating a \Session directly.
     class Session
       DEFAULT_HOST = "www.example.com"
 
@@ -122,7 +127,7 @@ module ActionDispatch
 
       include ActionDispatch::Routing::UrlFor
 
-      # Create and initialize a new Session instance.
+      # Create and initialize a new \Session instance.
       def initialize(app)
         super()
         @app = app
@@ -199,16 +204,17 @@ module ActionDispatch
       #   merged into the Rack env hash.
       # - +env+: Additional env to pass, as a Hash. The headers will be
       #   merged into the Rack env hash.
-      # - +xhr+: Set to +true+ if you want to make and Ajax request.
+      # - +xhr+: Set to +true+ if you want to make an Ajax request.
       #   Adds request headers characteristic of XMLHttpRequest e.g. HTTP_X_REQUESTED_WITH.
       #   The headers will be merged into the Rack env hash.
       # - +as+: Used for encoding the request with different content type.
       #   Supports +:json+ by default and will set the appropriate request headers.
       #   The headers will be merged into the Rack env hash.
       #
-      # This method is rarely used directly. Use +#get+, +#post+, or other standard
-      # HTTP methods in integration tests. +#process+ is only required when using a
-      # request method that doesn't have a method defined in the integration tests.
+      # This method is rarely used directly. Use RequestHelpers#get,
+      # RequestHelpers#post, or other standard HTTP methods in integration
+      # tests. +#process+ is only required when using a request method that
+      # doesn't have a method defined in the integration tests.
       #
       # This method returns the response status, after performing the request.
       # Furthermore, if this method was called from an ActionDispatch::IntegrationTest object,
@@ -226,7 +232,7 @@ module ActionDispatch
           method = :post
         end
 
-        if %r{://}.match?(path)
+        if path.include?("://")
           path = build_expanded_path(path) do |location|
             https! URI::HTTPS === location if location.scheme
 
@@ -252,10 +258,13 @@ module ActionDispatch
           "REQUEST_URI"    => path,
           "HTTP_HOST"      => host,
           "REMOTE_ADDR"    => remote_addr,
-          "CONTENT_TYPE"   => request_encoder.content_type,
           "HTTP_ACCEPT"    => request_encoder.accept_header || accept
         }
 
+        if request_encoder.content_type
+          request_env["CONTENT_TYPE"] = request_encoder.content_type
+        end
+
         wrapped_headers = Http::Headers.from_hash({})
         wrapped_headers.merge!(headers) if headers
 
@@ -363,13 +372,11 @@ module ActionDispatch
           reset_html_document = "@html_document = nil"
         end
 
-        definition = RUBY_VERSION >= "2.7" ? "..." : "*args"
-
         module_eval <<~RUBY, __FILE__, __LINE__ + 1
-          def #{method}(#{definition})
+          def #{method}(...)
             #{reset_html_document}
 
-            result = integration_session.#{method}(#{definition})
+            result = integration_session.#{method}(...)
             copy_session_variables!
             result
           end
@@ -404,7 +411,7 @@ module ActionDispatch
 
       # Copy the instance variables from the current session instance into the
       # test instance.
-      def copy_session_variables! #:nodoc:
+      def copy_session_variables! # :nodoc:
         @controller = @integration_session.controller
         @response   = @integration_session.response
         @request    = @integration_session.request
@@ -433,7 +440,7 @@ module ActionDispatch
           super
         end
       end
-      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+      ruby2_keywords(:method_missing)
     end
   end
 
@@ -442,8 +449,9 @@ module ActionDispatch
   # more completely than either unit or functional tests do, exercising the
   # entire stack, from the dispatcher to the database.
   #
-  # At its simplest, you simply extend <tt>IntegrationTest</tt> and write your tests
-  # using the get/post methods:
+  # At its simplest, you simply extend <tt>IntegrationTest</tt> and write your
+  # tests using the Integration::RequestHelpers#get and/or
+  # Integration::RequestHelpers#post methods:
   #
   #   require "test_helper"
   #
@@ -614,7 +622,7 @@ module ActionDispatch
   # the request format to JSON unless overridden), sets the content type to
   # "application/json" and encodes the parameters as JSON.
   #
-  # Calling +parsed_body+ on the response parses the response body based on the
+  # Calling TestResponse#parsed_body on the response parses the response body based on the
   # last response MIME type.
   #
   # Out of the box, only <tt>:json</tt> is supported. But for any custom MIME
@@ -626,9 +634,9 @@ module ActionDispatch
   #
   # Where +param_encoder+ defines how the params should be encoded and
   # +response_parser+ defines how the response body should be parsed through
-  # +parsed_body+.
+  # TestResponse#parsed_body.
   #
-  # Consult the Rails Testing Guide for more.
+  # Consult the {Rails Testing Guide}[https://guides.rubyonrails.org/testing.html] for more.
 
   class IntegrationTest < ActiveSupport::TestCase
     include TestProcess::FixtureFile

data/lib/action_dispatch/testing/request_encoder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "nokogiri"
+
 module ActionDispatch
   class RequestEncoder # :nodoc:
     class IdentityEncoder
@@ -50,6 +52,7 @@ module ActionDispatch
       @encoders[mime_name] = new(mime_name, param_encoder, response_parser)
     end
 
-    register_encoder :json, response_parser: -> body { JSON.parse(body) }
+    register_encoder :html, response_parser: -> body { Rails::Dom::Testing.html_document.parse(body) }
+    register_encoder :json, response_parser: -> body { JSON.parse(body, object_class: ActiveSupport::HashWithIndifferentAccess) }
   end
 end

data/lib/action_dispatch/testing/test_process.rb

@@ -8,47 +8,22 @@ module ActionDispatch
     module FixtureFile
       # Shortcut for <tt>Rack::Test::UploadedFile.new(File.join(ActionDispatch::IntegrationTest.file_fixture_path, path), type)</tt>:
       #
-      #   post :change_avatar, params: { avatar: fixture_file_upload('spongebob.png', 'image/png') }
+      #   post :change_avatar, params: { avatar: file_fixture_upload('david.png', 'image/png') }
       #
       # Default fixture files location is <tt>test/fixtures/files</tt>.
       #
       # To upload binary files on Windows, pass <tt>:binary</tt> as the last parameter.
       # This will not affect other platforms:
       #
-      #   post :change_avatar, params: { avatar: fixture_file_upload('spongebob.png', 'image/png', :binary) }
-      def fixture_file_upload(path, mime_type = nil, binary = false)
-        if self.class.respond_to?(:fixture_path) && self.class.fixture_path &&
-            !File.exist?(path)
-          original_path = path
-          path = Pathname.new(self.class.fixture_path).join(path)
-
-          if !self.class.file_fixture_path
-            ActiveSupport::Deprecation.warn(<<~EOM)
-              Passing a path to `fixture_file_upload` relative to `fixture_path` is deprecated.
-              In Rails 7.0, the path needs to be relative to `file_fixture_path` which you
-              haven't set yet. Set `file_fixture_path` to discard this warning.
-            EOM
-          elsif path.exist?
-            non_deprecated_path = Pathname(File.absolute_path(path)).relative_path_from(Pathname(File.absolute_path(self.class.file_fixture_path)))
-
-            if Pathname(original_path) != non_deprecated_path
-              ActiveSupport::Deprecation.warn(<<~EOM)
-                Passing a path to `fixture_file_upload` relative to `fixture_path` is deprecated.
-                In Rails 7.0, the path needs to be relative to `file_fixture_path`.
-
-                Please modify the call from
-                `fixture_file_upload("#{original_path}")` to `fixture_file_upload("#{non_deprecated_path}")`.
-              EOM
-            end
-          else
-            path = file_fixture(original_path)
-          end
-        elsif self.class.file_fixture_path && !File.exist?(path)
+      #   post :change_avatar, params: { avatar: file_fixture_upload('david.png', 'image/png', :binary) }
+      def file_fixture_upload(path, mime_type = nil, binary = false)
+        if self.class.file_fixture_path && !File.exist?(path)
           path = file_fixture(path)
         end
 
         Rack::Test::UploadedFile.new(path, mime_type, binary)
       end
+      alias_method :fixture_file_upload, :file_fixture_upload
     end
 
     include FixtureFile

data/lib/action_dispatch/testing/test_request.rb

@@ -32,7 +32,7 @@ module ActionDispatch
     end
 
     def port=(number)
-      set_header("SERVER_PORT", number.to_i)
+      set_header("SERVER_PORT", number)
     end
 
     def request_uri=(uri)

data/lib/action_dispatch/testing/test_response.rb

@@ -3,8 +3,8 @@
 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
+  # Integration test methods such as Integration::RequestHelpers#get
+  # and Integration::RequestHelpers#post return objects of class
   # TestResponse, which represent the HTTP response results of the requested
   # controller actions.
   #
@@ -14,6 +14,38 @@ module ActionDispatch
       new response.status, response.headers, response.body
     end
 
+    # Returns a parsed body depending on the response MIME type. When a parser
+    # corresponding to the MIME type is not found, it returns the raw body.
+    #
+    # ==== Examples
+    #   get "/posts"
+    #   response.content_type         # => "text/html; charset=utf-8"
+    #   response.parsed_body.class    # => Nokogiri::HTML5::Document
+    #   response.parsed_body.to_html  # => "<!DOCTYPE html>\n<html>\n..."
+    #
+    #   assert_pattern { response.parsed_body.at("main") => { content: "Hello, world" } }
+    #
+    #   response.parsed_body.at("main") => {name:, content:}
+    #   assert_equal "main", name
+    #   assert_equal "Some main content", content
+    #
+    #   get "/posts.json"
+    #   response.content_type         # => "application/json; charset=utf-8"
+    #   response.parsed_body.class    # => Array
+    #   response.parsed_body          # => [{"id"=>42, "title"=>"Title"},...
+    #
+    #   assert_pattern { response.parsed_body => [{ id: 42 }] }
+    #
+    #   get "/posts/42.json"
+    #   response.content_type         # => "application/json; charset=utf-8"
+    #   response.parsed_body.class    # => ActiveSupport::HashWithIndifferentAccess
+    #   response.parsed_body          # => {"id"=>42, "title"=>"Title"}
+    #
+    #   assert_pattern { response.parsed_body => [{ title: /title/i }] }
+    #
+    #   response.parsed_body => {id:, title:}
+    #   assert_equal 42, id
+    #   assert_equal "Title", title
     def parsed_body
       @parsed_body ||= response_parser.call(body)
     end