actionpack 3.2.19 → 4.2.11.3

data/lib/action_controller/test_case.rb

@@ -1,8 +1,10 @@
 require 'rack/session/abstract/id'
-require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/object/to_query'
-require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/module/anonymous'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/deprecation'
+
+require 'rails-dom-testing'
 
 module ActionController
   module TemplateAssertions
@@ -13,142 +15,189 @@ module ActionController
       teardown :teardown_subscriptions
     end
 
+    RENDER_TEMPLATE_INSTANCE_VARIABLES = %w{partials templates layouts files}.freeze
+
     def setup_subscriptions
-      @partials = Hash.new(0)
-      @templates = Hash.new(0)
-      @layouts = Hash.new(0)
+      RENDER_TEMPLATE_INSTANCE_VARIABLES.each do |instance_variable|
+        instance_variable_set("@_#{instance_variable}", Hash.new(0))
+      end
+
+      @_subscribers = []
 
-      ActiveSupport::Notifications.subscribe("render_template.action_view") do |name, start, finish, id, payload|
+      @_subscribers << ActiveSupport::Notifications.subscribe("render_template.action_view") do |_name, _start, _finish, _id, payload|
         path = payload[:layout]
         if path
-          @layouts[path] += 1
+          @_layouts[path] += 1
           if path =~ /^layouts\/(.*)/
-            @layouts[$1] += 1
+            @_layouts[$1] += 1
           end
         end
       end
 
-      ActiveSupport::Notifications.subscribe("!render_template.action_view") do |name, start, finish, id, payload|
-        path = payload[:virtual_path]
-        next unless path
-        partial = path =~ /^.*\/_[^\/]*$/
-        if partial
-          @partials[path] += 1
-          @partials[path.split("/").last] += 1
-          @templates[path] += 1
+      @_subscribers << ActiveSupport::Notifications.subscribe("!render_template.action_view") do |_name, _start, _finish, _id, payload|
+        if virtual_path = payload[:virtual_path]
+          partial = virtual_path =~ /^.*\/_[^\/]*$/
+
+          if partial
+            @_partials[virtual_path] += 1
+            @_partials[virtual_path.split("/").last] += 1
+          end
+
+          @_templates[virtual_path] += 1
         else
-          @templates[path] += 1
+          path = payload[:identifier]
+          if path
+            @_files[path] += 1
+            @_files[path.split("/").last] += 1
+          end
         end
       end
     end
 
     def teardown_subscriptions
-      ActiveSupport::Notifications.unsubscribe("render_template.action_view")
-      ActiveSupport::Notifications.unsubscribe("!render_template.action_view")
+      return unless defined?(@_subscribers)
+
+      @_subscribers.each do |subscriber|
+        ActiveSupport::Notifications.unsubscribe(subscriber)
+      end
     end
 
     def process(*args)
-      @partials = Hash.new(0)
-      @templates = Hash.new(0)
-      @layouts = Hash.new(0)
+      reset_template_assertion
       super
     end
 
+    def reset_template_assertion
+      RENDER_TEMPLATE_INSTANCE_VARIABLES.each do |instance_variable|
+        ivar_name = "@_#{instance_variable}"
+        if instance_variable_defined?(ivar_name)
+          instance_variable_get(ivar_name).clear
+        end
+      end
+    end
+
     # Asserts that the request was rendered with the appropriate template file or partials.
     #
-    # ==== Examples
-    #
     #   # assert that the "new" view template was rendered
     #   assert_template "new"
     #
+    #   # assert that the exact template "admin/posts/new" was rendered
+    #   assert_template %r{\Aadmin/posts/new\Z}
+    #
     #   # assert that the layout 'admin' was rendered
-    #   assert_template :layout => 'admin'
-    #   assert_template :layout => 'layouts/admin'
-    #   assert_template :layout => :admin
+    #   assert_template layout: 'admin'
+    #   assert_template layout: 'layouts/admin'
+    #   assert_template layout: :admin
     #
     #   # assert that no layout was rendered
-    #   assert_template :layout => nil
-    #   assert_template :layout => false
+    #   assert_template layout: nil
+    #   assert_template layout: false
     #
     #   # assert that the "_customer" partial was rendered twice
-    #   assert_template :partial => '_customer', :count => 2
+    #   assert_template partial: '_customer', count: 2
     #
     #   # assert that no partials were rendered
-    #   assert_template :partial => false
+    #   assert_template partial: false
+    #
+    #   # assert that a file was rendered
+    #   assert_template file: "README.rdoc"
+    #
+    #   # assert that no file was rendered
+    #   assert_template file: nil
+    #   assert_template file: false
     #
     # In a view test case, you can also assert that specific locals are passed
     # to partials:
     #
     #   # assert that the "_customer" partial was rendered with a specific object
-    #   assert_template :partial => '_customer', :locals => { :customer => @customer }
-    #
+    #   assert_template partial: '_customer', locals: { customer: @customer }
     def assert_template(options = {}, message = nil)
-      validate_request!
-      # Force body to be read in case the template is being streamed
+      # Force body to be read in case the template is being streamed.
       response.body
 
       case options
-      when NilClass, String, Symbol
+      when NilClass, Regexp, String, Symbol
         options = options.to_s if Symbol === options
-        rendered = @templates
-        msg = build_message(message,
-                "expecting <?> but rendering with <?>",
-                options, rendered.keys.join(', '))
-        assert_block(msg) do
-          if options
+        rendered = @_templates
+        msg = message || sprintf("expecting <%s> but rendering with <%s>",
+                options.inspect, rendered.keys)
+        matches_template =
+          case options
+          when String
+            !options.empty? && rendered.any? do |t, num|
+              options_splited = options.split(File::SEPARATOR)
+              t_splited = t.split(File::SEPARATOR)
+              t_splited.last(options_splited.size) == options_splited
+            end
+          when Regexp
             rendered.any? { |t,num| t.match(options) }
-          else
-            @templates.blank?
+          when NilClass
+            rendered.blank?
           end
-        end
+        assert matches_template, msg
       when Hash
+        options.assert_valid_keys(:layout, :partial, :locals, :count, :file)
+
         if options.key?(:layout)
           expected_layout = options[:layout]
-          msg = build_message(message,
-                  "expecting layout <?> but action rendered <?>",
-                  expected_layout, @layouts.keys)
+          msg = message || sprintf("expecting layout <%s> but action rendered <%s>",
+                  expected_layout, @_layouts.keys)
 
           case expected_layout
           when String, Symbol
-            assert(@layouts.keys.include?(expected_layout.to_s), msg)
+            assert_includes @_layouts.keys, expected_layout.to_s, msg
           when Regexp
-            assert(@layouts.keys.any? {|l| l =~ expected_layout }, msg)
+            assert(@_layouts.keys.any? {|l| l =~ expected_layout }, msg)
           when nil, false
-            assert(@layouts.empty?, msg)
+            assert(@_layouts.empty?, msg)
           end
         end
 
+        if options[:file]
+          assert_includes @_files.keys, options[:file]
+        elsif options.key?(:file)
+          assert @_files.blank?, "expected no files but #{@_files.keys} was rendered"
+        end
+
         if expected_partial = options[:partial]
           if expected_locals = options[:locals]
-            if defined?(@locals)
-              actual_locals = @locals[expected_partial.to_s.sub(/^_/,'')]
-              expected_locals.each_pair do |k,v|
-                assert_equal(v, actual_locals[k])
-              end
+            if defined?(@_rendered_views)
+              view = expected_partial.to_s.sub(/^_/, '').sub(/\/_(?=[^\/]+\z)/, '/')
+
+              partial_was_not_rendered_msg = "expected %s to be rendered but it was not." % view
+              assert_includes @_rendered_views.rendered_views, view, partial_was_not_rendered_msg
+
+              msg = 'expecting %s to be rendered with %s but was with %s' % [expected_partial,
+                                                                             expected_locals,
+                                                                             @_rendered_views.locals_for(view)]
+              assert(@_rendered_views.view_rendered?(view, options[:locals]), msg)
             else
               warn "the :locals option to #assert_template is only supported in a ActionView::TestCase"
             end
           elsif expected_count = options[:count]
-            actual_count = @partials[expected_partial]
-            msg = build_message(message,
-                    "expecting ? to be rendered ? time(s) but rendered ? time(s)",
+            actual_count = @_partials[expected_partial]
+            msg = message || sprintf("expecting %s to be rendered %s time(s) but rendered %s time(s)",
                      expected_partial, expected_count, actual_count)
             assert(actual_count == expected_count.to_i, msg)
           else
-            msg = build_message(message,
-                    "expecting partial <?> but action rendered <?>",
-                    options[:partial], @partials.keys)
-            assert(@partials.include?(expected_partial), msg)
+            msg = message || sprintf("expecting partial <%s> but action rendered <%s>",
+                    options[:partial], @_partials.keys)
+            assert_includes @_partials, expected_partial, msg
           end
         elsif options.key?(:partial)
-          assert @partials.empty?,
+          assert @_partials.empty?,
             "Expected no partials to be rendered"
         end
+      else
+        raise ArgumentError, "assert_template only accepts a String, Symbol, Hash, Regexp, or nil"
       end
     end
   end
 
   class TestRequest < ActionDispatch::TestRequest #:nodoc:
+    DEFAULT_ENV = ActionDispatch::TestRequest::DEFAULT_ENV.dup
+    DEFAULT_ENV.delete 'PATH_INFO'
+
     def initialize(env = {})
       super
 
@@ -156,13 +205,6 @@ module ActionController
       self.session_options = TestSession::DEFAULT_OPTIONS.merge(:id => SecureRandom.hex(16))
     end
 
-    class Result < ::Array #:nodoc:
-      def to_s() join '/' end
-      def self.new_escaped(strings)
-        new strings.collect {|str| uri_parser.unescape str}
-      end
-    end
-
     def assign_parameters(routes, controller_path, action, parameters = {})
       parameters = parameters.symbolize_keys.merge(:controller => controller_path, :action => action)
       extra_keys = routes.extra_keys(parameters)
@@ -176,22 +218,25 @@ module ActionController
           value = value.dup
         end
 
-        if extra_keys.include?(key.to_sym)
+        if extra_keys.include?(key)
           non_path_parameters[key] = value
         else
           if value.is_a?(Array)
-            value = Result.new(value.map(&:to_param))
+            value = value.map(&:to_param)
           else
             value = value.to_param
           end
 
-          path_parameters[key.to_s] = value
+          path_parameters[key] = value
         end
       end
 
       # Clear the combined params hash in case it was already referenced.
       @env.delete("action_dispatch.request.parameters")
 
+      # Clear the filter cache variables so they're not stale
+      @filtered_parameters = @filtered_env = @filtered_path = nil
+
       params = self.request_parameters.dup
       %w(controller action only_path).each do |k|
         params.delete(k)
@@ -207,7 +252,6 @@ module ActionController
       @formats = nil
       @env.delete_if { |k, v| k =~ /^(action_dispatch|rack)\.request/ }
       @env.delete_if { |k, v| k =~ /^action_dispatch\.rescue/ }
-      @symbolized_path_params = nil
       @method = @request_method = nil
       @fullpath = @ip = @remote_ip = @protocol = nil
       @env['action_dispatch.request.query_parameters'] = {}
@@ -220,33 +264,80 @@ module ActionController
       cookie_jar.update(@set_cookies)
       cookie_jar.recycle!
     end
+
+    private
+
+    def default_env
+      DEFAULT_ENV
+    end
   end
 
   class TestResponse < ActionDispatch::TestResponse
     def recycle!
-      @status = 200
-      @header = {}
-      @writer = lambda { |x| @body << x }
-      @block = nil
-      @length = 0
-      @body = []
-      @charset = @content_type = nil
-      @request = @template = nil
+      initialize
     end
   end
 
+  class LiveTestResponse < Live::Response
+    def recycle!
+      @body = nil
+      initialize
+    end
+
+    def body
+      @body ||= super
+    end
+
+    # Was the response successful?
+    alias_method :success?, :successful?
+
+    # Was the URL not found?
+    alias_method :missing?, :not_found?
+
+    # Were we redirected?
+    alias_method :redirect?, :redirection?
+
+    # Was there a server-side error?
+    alias_method :error?, :server_error?
+  end
+
+  # Methods #destroy and #load! are overridden to avoid calling methods on the
+  # @store object, which does not exist for the TestSession class.
   class TestSession < Rack::Session::Abstract::SessionHash #:nodoc:
     DEFAULT_OPTIONS = Rack::Session::Abstract::ID::DEFAULT_OPTIONS
 
     def initialize(session = {})
       super(nil, nil)
-      replace(session.stringify_keys)
+      @id = SecureRandom.hex(16)
+      @data = stringify_keys(session)
       @loaded = true
     end
 
     def exists?
       true
     end
+
+    def keys
+      @data.keys
+    end
+
+    def values
+      @data.values
+    end
+
+    def destroy
+      clear
+    end
+
+    def fetch(key, *args, &block)
+      @data.fetch(key.to_s, *args, &block)
+    end
+
+    private
+
+      def load!
+        @id
+      end
   end
 
   # Superclass for ActionController functional tests. Functional tests allow you to
@@ -258,7 +349,7 @@ module ActionController
   # == Basic example
   #
   # Functional tests are written as follows:
-  # 1. First, one uses the +get+, +post+, +put+, +delete+ or +head+ method to simulate
+  # 1. First, one uses the +get+, +post+, +patch+, +put+, +delete+ or +head+ method to simulate
   #    an HTTP request.
   # 2. Then, one asserts whether the current state is as expected. "State" can be anything:
   #    the controller's HTTP response, the database contents, etc.
@@ -268,17 +359,24 @@ module ActionController
   #   class BooksControllerTest < ActionController::TestCase
   #     def test_create
   #       # Simulate a POST response with the given HTTP parameters.
-  #       post(:create, :book => { :title => "Love Hina" })
+  #       post(:create, book: { title: "Love Hina" })
   #
   #       # Assert that the controller tried to redirect us to
   #       # the created book's URI.
   #       assert_response :found
   #
   #       # Assert that the controller really put the book in the database.
-  #       assert_not_nil Book.find_by_title("Love Hina")
+  #       assert_not_nil Book.find_by(title: "Love Hina")
   #     end
   #   end
   #
+  # You can also send a real document in the simulated HTTP request.
+  #
+  #   def test_create
+  #     json = {book: { title: "Love Hina" }}.to_json
+  #     post :create, json
+  #   end
+  #
   # == Special instance variables
   #
   # ActionController::TestCase will also automatically provide the following instance
@@ -349,29 +447,29 @@ module ActionController
   # == \Testing named routes
   #
   # If you're using named routes, they can be easily tested using the original named routes' methods straight in the test case.
-  # Example:
   #
-  #  assert_redirected_to page_url(:title => 'foo')
+  #  assert_redirected_to page_url(title: 'foo')
   class TestCase < ActiveSupport::TestCase
     module Behavior
       extend ActiveSupport::Concern
       include ActionDispatch::TestProcess
+      include ActiveSupport::Testing::ConstantLookup
+      include Rails::Dom::Testing::Assertions
 
       attr_reader :response, :request
 
       module ClassMethods
 
         # Sets the controller class name. Useful if the name can't be inferred from test class.
-        # Normalizes +controller_class+ before using. Examples:
+        # Normalizes +controller_class+ before using.
         #
         #   tests WidgetController
         #   tests :widget
         #   tests 'widget'
-        #
         def tests(controller_class)
           case controller_class
           when String, Symbol
-            self.controller_class = "#{controller_class.to_s.underscore}_controller".camelize.constantize
+            self.controller_class = "#{controller_class.to_s.camelize}Controller".constantize
           when Class
             self.controller_class = controller_class
           else
@@ -380,7 +478,6 @@ module ActionController
         end
 
         def controller_class=(new_class)
-          prepare_controller_class(new_class) if new_class
           self._controller_class = new_class
         end
 
@@ -393,38 +490,58 @@ module ActionController
         end
 
         def determine_default_controller_class(name)
-          name.sub(/Test$/, '').safe_constantize
-        end
-
-        def prepare_controller_class(new_class)
-          new_class.send :include, ActionController::TestCase::RaiseActionExceptions
+          determine_constant_from_test_name(name) do |constant|
+            Class === constant && constant < ActionController::Metal
+          end
         end
+      end
 
+      # Simulate a GET request with the given parameters.
+      #
+      # - +action+: The controller action to call.
+      # - +parameters+: The HTTP parameters that you want to pass. This may
+      #   be +nil+, a hash, or a string that is appropriately encoded
+      #   (<tt>application/x-www-form-urlencoded</tt> or <tt>multipart/form-data</tt>).
+      # - +session+: A hash of parameters to store in the session. This may be +nil+.
+      # - +flash+: A hash of parameters to store in the flash. This may be +nil+.
+      #
+      # You can also simulate POST, PATCH, PUT, DELETE, and HEAD requests with
+      # +post+, +patch+, +put+, +delete+, and +head+.
+      #
+      # Note that the request method is not verified. The different methods are
+      # available to make the tests more expressive.
+      def get(action, *args)
+        process(action, "GET", *args)
       end
 
-      # Executes a request simulating GET HTTP method and set/volley the response
-      def get(action, parameters = nil, session = nil, flash = nil)
-        process(action, parameters, session, flash, "GET")
+      # Simulate a POST request with the given parameters and set/volley the response.
+      # See +get+ for more details.
+      def post(action, *args)
+        process(action, "POST", *args)
       end
 
-      # Executes a request simulating POST HTTP method and set/volley the response
-      def post(action, parameters = nil, session = nil, flash = nil)
-        process(action, parameters, session, flash, "POST")
+      # Simulate a PATCH request with the given parameters and set/volley the response.
+      # See +get+ for more details.
+      def patch(action, *args)
+        process(action, "PATCH", *args)
       end
 
-      # Executes a request simulating PUT HTTP method and set/volley the response
-      def put(action, parameters = nil, session = nil, flash = nil)
-        process(action, parameters, session, flash, "PUT")
+      # Simulate a PUT request with the given parameters and set/volley the response.
+      # See +get+ for more details.
+      def put(action, *args)
+        process(action, "PUT", *args)
       end
 
-      # Executes a request simulating DELETE HTTP method and set/volley the response
-      def delete(action, parameters = nil, session = nil, flash = nil)
-        process(action, parameters, session, flash, "DELETE")
+      # Simulate a DELETE request with the given parameters and set/volley the response.
+      # See +get+ for more details.
+      def delete(action, *args)
+        process(action, "DELETE", *args)
       end
 
-      # Executes a request simulating HEAD HTTP method and set/volley the response
-      def head(action, parameters = nil, session = nil, flash = nil)
-        process(action, parameters, session, flash, "HEAD")
+      # Simulate a HEAD request with the given parameters and set/volley the response.
+      # See +get+ for more details.
+      def head(action, *args)
+        process(action, "HEAD", *args)
       end
 
       def xml_http_request(request_method, action, parameters = nil, session = nil, flash = nil)
@@ -450,65 +567,129 @@ module ActionController
         end
       end
 
-      def process(action, parameters = nil, session = nil, flash = nil, http_method = 'GET')
+      # Simulate a HTTP request to +action+ by specifying request method,
+      # parameters and set/volley the response.
+      #
+      # - +action+: The controller action to call.
+      # - +http_method+: Request method used to send the http request. Possible values
+      #   are +GET+, +POST+, +PATCH+, +PUT+, +DELETE+, +HEAD+. Defaults to +GET+.
+      # - +parameters+: The HTTP parameters. This may be +nil+, a hash, or a
+      #   string that is appropriately encoded (+application/x-www-form-urlencoded+
+      #   or +multipart/form-data+).
+      # - +session+: A hash of parameters to store in the session. This may be +nil+.
+      # - +flash+: A hash of parameters to store in the flash. This may be +nil+.
+      #
+      # Example calling +create+ action and sending two params:
+      #
+      #   process :create, 'POST', user: { name: 'Gaurish Sharma', email: 'user@example.com' }
+      #
+      # Example sending parameters, +nil+ session and setting a flash message:
+      #
+      #   process :view, 'GET', { id: 7 }, nil, { notice: 'This is flash message' }
+      #
+      # To simulate +GET+, +POST+, +PATCH+, +PUT+, +DELETE+ and +HEAD+ requests
+      # prefer using #get, #post, #patch, #put, #delete and #head methods
+      # respectively which will make tests more expressive.
+      #
+      # Note that the request method is not verified.
+      def process(action, http_method = 'GET', *args)
+        check_required_ivars
+
+        if args.first.is_a?(String) && http_method != 'HEAD'
+          @request.env['RAW_POST_DATA'] = args.shift
+        end
+
+        parameters, session, flash = args
+        parameters ||= {}
+
         # Ensure that numbers and symbols passed as params are converted to
         # proper params, as is the case when engaging rack.
         parameters = paramify_values(parameters) if html_format?(parameters)
 
-        # Sanity check for required instance variables so we can give an
-        # understandable error message.
-        %w(@routes @controller @request @response).each do |iv_name|
-          if !(instance_variable_names.include?(iv_name) || instance_variable_names.include?(iv_name.to_sym)) || instance_variable_get(iv_name).nil?
-            raise "#{iv_name} is nil: make sure you set it in your test's setup method."
-          end
+        @html_document = nil
+        @html_scanner_document = nil
+
+        unless @controller.respond_to?(:recycle!)
+          @controller.extend(Testing::Functional)
         end
 
         @request.recycle!
         @response.recycle!
-        @controller.response_body = nil
-        @controller.formats = nil
-        @controller.params = nil
+        @controller.recycle!
 
-        @html_document = nil
         @request.env['REQUEST_METHOD'] = http_method
 
-        parameters ||= {}
         controller_class_name = @controller.class.anonymous? ?
-          "anonymous_controller" :
+          "anonymous" :
           @controller.class.controller_path
 
         @request.assign_parameters(@routes, controller_class_name, action.to_s, parameters)
 
-        @request.session = ActionController::TestSession.new(session) if session
-        @request.session["flash"] = @request.flash.update(flash || {})
-        @request.session["flash"].sweep
+        @request.session.update(session) if session
+        @request.flash.update(flash || {})
+
+        @controller.request  = @request
+        @controller.response = @response
 
-        @controller.request = @request
         build_request_uri(action, parameters)
-        @controller.class.class_eval { include Testing }
+
+        name = @request.parameters[:action]
+
         @controller.recycle!
-        @controller.process_with_new_base_test(@request, @response)
+        @controller.process(name)
+
+        if cookies = @request.env['action_dispatch.cookies']
+          unless @response.committed?
+            cookies.write(@response)
+          end
+        end
+        @response.prepare!
+
         @assigns = @controller.respond_to?(:view_assigns) ? @controller.view_assigns : {}
-        @request.session.delete('flash') if @request.session['flash'].blank?
+
+        if flash_value = @request.flash.to_session_value
+          @request.session['flash'] = flash_value
+        end
+
         @response
       end
 
       def setup_controller_request_and_response
-        @request = TestRequest.new
-        @response = TestResponse.new
+        @controller = nil unless defined? @controller
+
+        response_klass = TestResponse
 
         if klass = self.class.controller_class
-          @controller ||= klass.new rescue nil
+          if klass < ActionController::Live
+            response_klass = LiveTestResponse
+          end
+          unless @controller
+            begin
+              @controller = klass.new
+            rescue
+              warn "could not construct controller #{klass}" if $VERBOSE
+            end
+          end
         end
 
-        @request.env.delete('PATH_INFO')
+        @request          = build_request
+        @response         = build_response response_klass
+        @response.request = @request
 
-        if defined?(@controller) && @controller
+        if @controller
           @controller.request = @request
           @controller.params = {}
         end
       end
 
+      def build_request
+        TestRequest.new
+      end
+
+      def build_response(klass)
+        klass.new
+      end
+
       included do
         include ActionController::TemplateAssertions
         include ActionDispatch::Assertions
@@ -516,18 +697,52 @@ module ActionController
         setup :setup_controller_request_and_response
       end
 
-    private
+      private
+
+      def document_root_element
+        html_document.root
+      end
+
+      def check_required_ivars
+        # Sanity check for required instance variables so we can give an
+        # understandable error message.
+        [:@routes, :@controller, :@request, :@response].each do |iv_name|
+          if !instance_variable_defined?(iv_name) || instance_variable_get(iv_name).nil?
+            raise "#{iv_name} is nil: make sure you set it in your test's setup method."
+          end
+        end
+      end
 
       def build_request_uri(action, parameters)
         unless @request.env["PATH_INFO"]
           options = @controller.respond_to?(:url_options) ? @controller.__send__(:url_options).merge(parameters) : parameters
           options.update(
-            :only_path => true,
             :action => action,
             :relative_url_root => nil,
-            :_path_segments => @request.symbolized_path_parameters)
+            :_recall => @request.path_parameters)
+
+          if route_name = options.delete(:use_route)
+            ActiveSupport::Deprecation.warn <<-MSG.squish
+              Passing the `use_route` option in functional tests are deprecated.
+              Support for this option in the `process` method (and the related
+              `get`, `head`, `post`, `patch`, `put` and `delete` helpers) will
+              be removed in the next version without replacement.
+
+              Functional tests are essentially unit tests for controllers and
+              they should not require knowledge to how the application's routes
+              are configured. Instead, you should explicitly pass the appropiate
+              params to the `process` method.
+
+              Previously the engines guide also contained an incorrect example
+              that recommended using this option to test an engine's controllers
+              within the dummy application. That recommendation was incorrect
+              and has since been corrected. Instead, you should override the
+              `@routes` variable in the test case with `Foo::Engine.routes`. See
+              the updated engines guide for details.
+            MSG
+          end
 
-          url, query_string = @routes.url_for(options).split("?", 2)
+          url, query_string = @routes.path_for(options, route_name).split("?", 2)
 
           @request.env["SCRIPT_NAME"] = @controller.config.relative_url_root
           @request.env["PATH_INFO"] = url
@@ -536,40 +751,11 @@ module ActionController
       end
 
       def html_format?(parameters)
-        return true unless parameters.is_a?(Hash)
-        format = Mime[parameters[:format]]
-        format.nil? || format.html?
+        return true unless parameters.key?(:format)
+        Mime.fetch(parameters[:format]) { Mime['html'] }.html?
       end
     end
 
-    # When the request.remote_addr remains the default for testing, which is 0.0.0.0, the exception is simply raised inline
-    # (skipping the regular exception handling from rescue_action). If the request.remote_addr is anything else, the regular
-    # rescue_action process takes place. This means you can test your rescue_action code by setting remote_addr to something else
-    # than 0.0.0.0.
-    #
-    # The exception is stored in the exception accessor for further inspection.
-    module RaiseActionExceptions
-      def self.included(base)
-        unless base.method_defined?(:exception) && base.method_defined?(:exception=)
-          base.class_eval do
-            attr_accessor :exception
-            protected :exception, :exception=
-          end
-        end
-      end
-
-      protected
-        def rescue_action_without_handler(e)
-          self.exception = e
-
-          if request.remote_addr == "0.0.0.0"
-            raise(e)
-          else
-            super(e)
-          end
-        end
-    end
-
     include Behavior
   end
 end