actionpack 3.2.19 → 4.0.0

data/lib/action_controller/test_case.rb

@@ -1,8 +1,7 @@
 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'
 
 module ActionController
   module TemplateAssertions
@@ -14,30 +13,41 @@ module ActionController
     end
 
     def setup_subscriptions
-      @partials = Hash.new(0)
-      @templates = Hash.new(0)
-      @layouts = Hash.new(0)
+      @_partials = Hash.new(0)
+      @_templates = Hash.new(0)
+      @_layouts = Hash.new(0)
+      @_files = Hash.new(0)
 
-      ActiveSupport::Notifications.subscribe("render_template.action_view") do |name, start, finish, id, payload|
+      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|
+      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
-        else
-          @templates[path] += 1
+          @_partials[path] += 1
+          @_partials[path.split("/").last] += 1
+        end
+
+        @_templates[path] += 1
+      end
+
+      ActiveSupport::Notifications.subscribe("!render_template.action_view") do |_name, _start, _finish, _id, payload|
+        next if payload[:virtual_path] # files don't have virtual path
+
+        path = payload[:identifier]
+        if path
+          @_files[path] += 1
+          @_files[path.split("/").last] += 1
         end
       end
     end
@@ -48,107 +58,125 @@ module ActionController
     end
 
     def process(*args)
-      @partials = Hash.new(0)
-      @templates = Hash.new(0)
-      @layouts = Hash.new(0)
+      @_partials = Hash.new(0)
+      @_templates = Hash.new(0)
+      @_layouts = Hash.new(0)
       super
     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
     #
     # 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]
+        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 +184,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)
@@ -180,7 +201,7 @@ module ActionController
           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
@@ -220,33 +241,53 @@ 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
 
+  # 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
+
+    private
+
+      def load!
+        @id
+      end
   end
 
   # Superclass for ActionController functional tests. Functional tests allow you to
@@ -258,7 +299,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 +309,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 +397,28 @@ 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
 
       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
@@ -393,7 +440,9 @@ module ActionController
         end
 
         def determine_default_controller_class(name)
-          name.sub(/Test$/, '').safe_constantize
+          determine_constant_from_test_name(name) do |constant|
+            Class === constant && constant < ActionController::Metal
+          end
         end
 
         def prepare_controller_class(new_class)
@@ -402,29 +451,52 @@ module ActionController
 
       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 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, HEAD, and OPTIONS requests with
+      # +post+, +patch+, +put+, +delete+, +head+, and +options+.
+      #
+      # 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
+
+      # 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 +522,94 @@ module ActionController
         end
       end
 
-      def process(action, parameters = nil, session = nil, flash = nil, http_method = 'GET')
+      def process(action, http_method = 'GET', *args)
+        check_required_ivars
+        http_method, args = handle_old_process_api(http_method, args, caller)
+
+        if args.first.is_a?(String) && http_method != 'HEAD'
+          @request.env['RAW_POST_DATA'] = args.shift
+        end
+
+        parameters, session, flash = args
+
         # 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
+
+        unless @controller.respond_to?(:recycle!)
+          @controller.extend(Testing::Functional)
+          @controller.class.class_eval { include Testing }
         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" :
-          @controller.class.controller_path
+          "anonymous" :
+          @controller.class.name.underscore.sub(/_controller$/, '')
 
         @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 }
-        @controller.recycle!
-        @controller.process_with_new_base_test(@request, @response)
+
+        name = @request.parameters[:action]
+
+        @controller.process(name)
+
+        if cookies = @request.env['action_dispatch.cookies']
+          cookies.write(@response)
+        end
+        @response.prepare!
+
         @assigns = @controller.respond_to?(:view_assigns) ? @controller.view_assigns : {}
+        @request.session['flash'] = @request.flash.to_session_value
         @request.session.delete('flash') if @request.session['flash'].blank?
         @response
       end
 
       def setup_controller_request_and_response
-        @request = TestRequest.new
-        @response = TestResponse.new
+        @request          = build_request
+        @response         = build_response
+        @response.request = @request
+
+        @controller = nil unless defined? @controller
 
         if klass = self.class.controller_class
-          @controller ||= klass.new rescue nil
+          unless @controller
+            begin
+              @controller = klass.new
+            rescue
+              warn "could not construct controller #{klass}" if $VERBOSE
+            end
+          end
         end
 
-        @request.env.delete('PATH_INFO')
-
-        if defined?(@controller) && @controller
+        if @controller
           @controller.request = @request
           @controller.params = {}
         end
       end
 
+      def build_request
+        TestRequest.new
+      end
+
+      def build_response
+        TestResponse.new
+      end
+
       included do
         include ActionController::TemplateAssertions
         include ActionDispatch::Assertions
@@ -516,7 +617,27 @@ module ActionController
         setup :setup_controller_request_and_response
       end
 
-    private
+      private
+      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 handle_old_process_api(http_method, args, callstack)
+        # 4.0: Remove this method.
+        if http_method.is_a?(Hash)
+          ActiveSupport::Deprecation.warn("TestCase#process now expects the HTTP method as second argument: process(action, http_method, params, session, flash)", callstack)
+          args.unshift(http_method)
+          http_method = args.last.is_a?(String) ? args.last : "GET"
+        end
+
+        [http_method, args]
+      end
 
       def build_request_uri(action, parameters)
         unless @request.env["PATH_INFO"]
@@ -525,7 +646,7 @@ module ActionController
             :only_path => true,
             :action => action,
             :relative_url_root => nil,
-            :_path_segments => @request.symbolized_path_parameters)
+            :_recall => @request.symbolized_path_parameters)
 
           url, query_string = @routes.url_for(options).split("?", 2)
 
@@ -537,8 +658,7 @@ module ActionController
 
       def html_format?(parameters)
         return true unless parameters.is_a?(Hash)
-        format = Mime[parameters[:format]]
-        format.nil? || format.html?
+        Mime.fetch(parameters[:format]) { Mime['html'] }.html?
       end
     end
 
@@ -549,7 +669,7 @@ module ActionController
     #
     # The exception is stored in the exception accessor for further inspection.
     module RaiseActionExceptions
-      def self.included(base)
+      def self.included(base) #:nodoc:
         unless base.method_defined?(:exception) && base.method_defined?(:exception=)
           base.class_eval do
             attr_accessor :exception

data/lib/action_controller/vendor/html-scanner.rb

@@ -1,20 +1,5 @@
-$LOAD_PATH << "#{File.dirname(__FILE__)}/html-scanner"
+require 'action_view/vendor/html-scanner'
+require 'active_support/deprecation'
 
-module HTML
-  extend ActiveSupport::Autoload
-
-  eager_autoload do
-    autoload :CDATA, 'html/node'
-    autoload :Document, 'html/document'
-    autoload :FullSanitizer, 'html/sanitizer'
-    autoload :LinkSanitizer, 'html/sanitizer'
-    autoload :Node, 'html/node'
-    autoload :Sanitizer, 'html/sanitizer'
-    autoload :Selector, 'html/selector'
-    autoload :Tag, 'html/node'
-    autoload :Text, 'html/node'
-    autoload :Tokenizer, 'html/tokenizer'
-    autoload :Version, 'html/version'
-    autoload :WhiteListSanitizer, 'html/sanitizer'
-  end
-end
+ActiveSupport::Deprecation.warn 'Vendored html-scanner was moved to action_view, please require "action_view/vendor/html-scanner" instead. ' +
+                                'This file will be removed in Rails 4.1'