actionpack 2.3.18 → 3.0.0.beta

data/lib/action_dispatch/testing/assertions.rb

@@ -0,0 +1,21 @@
+module ActionDispatch
+  module Assertions
+    autoload :DomAssertions, 'action_dispatch/testing/assertions/dom'
+    autoload :ModelAssertions, 'action_dispatch/testing/assertions/model'
+    autoload :ResponseAssertions, 'action_dispatch/testing/assertions/response'
+    autoload :RoutingAssertions, 'action_dispatch/testing/assertions/routing'
+    autoload :SelectorAssertions, 'action_dispatch/testing/assertions/selector'
+    autoload :TagAssertions, 'action_dispatch/testing/assertions/tag'
+
+    extend ActiveSupport::Concern
+
+    included do
+      include DomAssertions
+      include ModelAssertions
+      include ResponseAssertions
+      include RoutingAssertions
+      include SelectorAssertions
+      include TagAssertions
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'action_controller/vendor/html-scanner'
+
+module ActionDispatch
+  module Assertions
+    module DomAssertions
+      # Test two HTML strings for equivalency (e.g., identical up to reordering of attributes)
+      #
+      # ==== Examples
+      #
+      #   # assert that the referenced method generates the appropriate HTML string
+      #   assert_dom_equal '<a href="http://www.example.com">Apples</a>', link_to("Apples", "http://www.example.com")
+      #
+      def assert_dom_equal(expected, actual, message = "")
+        expected_dom = HTML::Document.new(expected).root
+        actual_dom   = HTML::Document.new(actual).root
+        full_message = build_message(message, "<?> expected to be == to\n<?>.", expected_dom.to_s, actual_dom.to_s)
+
+        assert_block(full_message) { expected_dom == actual_dom }
+      end
+
+      # The negated form of +assert_dom_equivalent+.
+      #
+      # ==== Examples
+      #
+      #   # assert that the referenced method does not generate the specified HTML string
+      #   assert_dom_not_equal '<a href="http://www.example.com">Apples</a>', link_to("Oranges", "http://www.example.com")
+      #
+      def assert_dom_not_equal(expected, actual, message = "")
+        expected_dom = HTML::Document.new(expected).root
+        actual_dom   = HTML::Document.new(actual).root
+        full_message = build_message(message, "<?> expected to be != to\n<?>.", expected_dom.to_s, actual_dom.to_s)
+
+        assert_block(full_message) { expected_dom != actual_dom }
+      end
+    end
+  end
+end

data/lib/{action_controller/assertions/model_assertions.rb → action_dispatch/testing/assertions/model.rb}

@@ -1,4 +1,4 @@
-module ActionController
+module ActionDispatch
   module Assertions
     module ModelAssertions
       # Ensures that the passed record is valid by Active Record standards and
@@ -12,9 +12,7 @@ module ActionController
       #
       def assert_valid(record)
         ::ActiveSupport::Deprecation.warn("assert_valid is deprecated. Use assert record.valid? instead", caller)
-        clean_backtrace do
-          assert record.valid?, record.errors.full_messages.join("\n")
-        end
+        assert record.valid?, record.errors.full_messages.join("\n")
       end
     end
   end

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

@@ -0,0 +1,154 @@
+module ActionDispatch
+  module Assertions
+    # A small suite of assertions that test responses from Rails applications.
+    module ResponseAssertions
+      extend ActiveSupport::Concern
+
+      included do
+        # TODO: Need to pull in AV::Template monkey patches that track which
+        # templates are rendered. assert_template should probably be part
+        # of AV instead of AD.
+        require 'action_view/test_case'
+      end
+
+      # Asserts that the response is one of the following types:
+      #
+      # * <tt>:success</tt>   - Status code was 200
+      # * <tt>:redirect</tt>  - Status code was in the 300-399 range
+      # * <tt>:missing</tt>   - Status code was 404
+      # * <tt>:error</tt>     - Status code was in the 500-599 range
+      #
+      # You can also pass an explicit status number like assert_response(501)
+      # or its symbolic equivalent assert_response(:not_implemented).
+      # See ActionDispatch::StatusCodes for a full list.
+      #
+      # ==== Examples
+      #
+      #   # assert that the response was a redirection
+      #   assert_response :redirect
+      #
+      #   # assert that the response code was status code 401 (unauthorized)
+      #   assert_response 401
+      #
+      def assert_response(type, message = nil)
+        validate_request!
+
+        if [ :success, :missing, :redirect, :error ].include?(type) && @response.send("#{type}?")
+          assert_block("") { true } # to count the assertion
+        elsif type.is_a?(Fixnum) && @response.response_code == type
+          assert_block("") { true } # to count the assertion
+        elsif type.is_a?(Symbol) && @response.response_code == Rack::Utils::SYMBOL_TO_STATUS_CODE[type]
+          assert_block("") { true } # to count the assertion
+        else
+          assert_block(build_message(message, "Expected response to be a <?>, but was <?>", type, @response.response_code)) { false }
+        end
+      end
+
+      # Assert that the redirection options passed in match those of the redirect called in the latest action.
+      # This match can be partial, such that assert_redirected_to(:controller => "weblog") will also
+      # match the redirection of redirect_to(:controller => "weblog", :action => "show") and so on.
+      #
+      # ==== Examples
+      #
+      #   # assert that the redirection was to the "index" action on the WeblogController
+      #   assert_redirected_to :controller => "weblog", :action => "index"
+      #
+      #   # assert that the redirection was to the named route login_url
+      #   assert_redirected_to login_url
+      #
+      #   # assert that the redirection was to the url for @customer
+      #   assert_redirected_to @customer
+      #
+      def assert_redirected_to(options = {}, message=nil)
+        validate_request!
+
+        assert_response(:redirect, message)
+        return true if options == @response.location
+
+        redirected_to_after_normalisation = normalize_argument_to_redirection(@response.location)
+        options_after_normalisation       = normalize_argument_to_redirection(options)
+
+        if redirected_to_after_normalisation != options_after_normalisation
+          flunk "Expected response to be a redirect to <#{options_after_normalisation}> but was a redirect to <#{redirected_to_after_normalisation}>"
+        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 "_customer" partial was rendered twice
+      #   assert_template :partial => '_customer', :count => 2
+      #
+      #   # assert that no partials were rendered
+      #   assert_template :partial => false
+      #
+      def assert_template(options = {}, message = nil)
+        validate_request!
+
+        case options
+         when NilClass, String
+          rendered = (@controller.template.rendered[:template] || []).map { |t| t.identifier }
+          msg = build_message(message,
+                  "expecting <?> but rendering with <?>",
+                  options, rendered.join(', '))
+          assert_block(msg) do
+            if options.nil?
+              @controller.template.rendered[:template].blank?
+            else
+              rendered.any? { |t| t.match(options) }
+            end
+          end
+        when Hash
+          if expected_partial = options[:partial]
+            partials = @controller.template.rendered[:partials]
+            if expected_count = options[:count]
+              found = partials.detect { |p, _| p.identifier.match(expected_partial) }
+              actual_count = found.nil? ? 0 : found.second
+              msg = build_message(message,
+                      "expecting ? to be rendered ? time(s) but rendered ? 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.keys.any? { |p| p.identifier.match(expected_partial) }, msg)
+            end
+          else
+            assert @controller.template.rendered[:partials].empty?,
+              "Expected no partials to be rendered"
+          end
+        end
+      end
+
+      private
+        # Proxy to to_param if the object will respond to it.
+        def parameterize(value)
+          value.respond_to?(:to_param) ? value.to_param : value
+        end
+
+        def normalize_argument_to_redirection(fragment)
+          after_routing = @controller.url_for(fragment)
+          if after_routing =~ %r{^\w+://.*}
+            after_routing
+          else
+            # FIXME - this should probably get removed.
+            if after_routing.first != '/'
+              after_routing = '/' + after_routing
+            end
+            @request.protocol + @request.host_with_port + after_routing
+          end
+        end
+
+        def validate_request!
+          unless @request.is_a?(ActionDispatch::Request)
+            raise ArgumentError, "@request must be an ActionDispatch::Request"
+          end
+        end
+    end
+  end
+end

data/lib/{action_controller/assertions/routing_assertions.rb → action_dispatch/testing/assertions/routing.rb}

@@ -1,4 +1,6 @@
-module ActionController
+require 'active_support/core_ext/hash/diff'
+
+module ActionDispatch
   module Assertions
     # Suite of assertions to test routes generated by Rails and the handling of requests made to them.
     module RoutingAssertions
@@ -10,29 +12,29 @@ module ActionController
       # and a :method containing the required HTTP verb.
       #
       #   # assert that POSTing to /items will call the create action on ItemsController
-      #   assert_recognizes {:controller => 'items', :action => 'create'}, {:path => 'items', :method => :post}
+      #   assert_recognizes({:controller => 'items', :action => 'create'}, {:path => 'items', :method => :post})
       #
       # You can also pass in +extras+ with a hash containing URL parameters that would normally be in the query string.  This can be used
       # to assert that values in the query string string will end up in the params hash correctly.  To test query strings you must use the
       # extras argument, appending the query string on the path directly will not work.  For example:
       #
       #   # assert that a path of '/items/list/1?view=print' returns the correct options
-      #   assert_recognizes {:controller => 'items', :action => 'list', :id => '1', :view => 'print'}, 'items/list/1', { :view => "print" }
+      #   assert_recognizes({:controller => 'items', :action => 'list', :id => '1', :view => 'print'}, 'items/list/1', { :view => "print" })
       #
       # The +message+ parameter allows you to pass in an error message that is displayed upon failure.
       #
       # ==== Examples
       #   # Check the default route (i.e., the index action)
-      #   assert_recognizes {:controller => 'items', :action => 'index'}, 'items'
+      #   assert_recognizes({:controller => 'items', :action => 'index'}, 'items')
       #
       #   # Test a specific action
-      #   assert_recognizes {:controller => 'items', :action => 'list'}, 'items/list'
+      #   assert_recognizes({:controller => 'items', :action => 'list'}, 'items/list')
       #
       #   # Test an action with a parameter
-      #   assert_recognizes {:controller => 'items', :action => 'destroy', :id => '1'}, 'items/destroy/1'
+      #   assert_recognizes({:controller => 'items', :action => 'destroy', :id => '1'}, 'items/destroy/1')
       #
       #   # Test a custom route
-      #   assert_recognizes {:controller => 'items', :action => 'show', :id => '1'}, 'view/item1'
+      #   assert_recognizes({:controller => 'items', :action => 'show', :id => '1'}, 'view/item1')
       #
       #   # Check a Simply RESTful generated route
       #   assert_recognizes list_items_url, 'items/list'
@@ -44,19 +46,16 @@ module ActionController
           request_method = nil
         end
 
-        clean_backtrace do
-          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
-          request = recognized_request_for(path, request_method)
+        request = recognized_request_for(path, request_method)
 
-          expected_options = expected_options.clone
-          extras.each_key { |key| expected_options.delete key } unless extras.nil?
+        expected_options = expected_options.clone
+        extras.each_key { |key| expected_options.delete key } unless extras.nil?
 
-          expected_options.stringify_keys!
-          routing_diff = expected_options.diff(request.path_parameters)
-          msg = build_message(message, "The recognized options <?> did not match <?>, difference: <?>",
-              request.path_parameters, expected_options, expected_options.diff(request.path_parameters))
-          assert_block(msg) { request.path_parameters == expected_options }
-        end
+        expected_options.stringify_keys!
+        routing_diff = expected_options.diff(request.path_parameters)
+        msg = build_message(message, "The recognized options <?> did not match <?>, difference: <?>",
+            request.path_parameters, expected_options, expected_options.diff(request.path_parameters))
+        assert_block(msg) { request.path_parameters == expected_options }
       end
 
       # Asserts that the provided options can be used to generate the provided path.  This is the inverse of +assert_recognizes+.
@@ -78,21 +77,18 @@ module ActionController
       #   # 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)
-        clean_backtrace do
-          expected_path = "/#{expected_path}" unless expected_path[0] == ?/
-          # Load routes.rb if it hasn't been loaded.
-          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+        expected_path = "/#{expected_path}" unless expected_path[0] == ?/
+        # Load routes.rb if it hasn't been loaded.
 
-          generated_path, extra_keys = ActionController::Routing::Routes.generate_extras(options, defaults)
-          found_extras = options.reject {|k, v| ! extra_keys.include? k}
+        generated_path, extra_keys = ActionController::Routing::Routes.generate_extras(options, defaults)
+        found_extras = options.reject {|k, v| ! extra_keys.include? k}
 
-          msg = build_message(message, "found extras <?>, not <?>", found_extras, extras)
-          assert_block(msg) { found_extras == extras }
+        msg = build_message(message, "found extras <?>, not <?>", found_extras, extras)
+        assert_block(msg) { found_extras == extras }
 
-          msg = build_message(message, "The generated path <?> did not match <?>", generated_path,
-              expected_path)
-          assert_block(msg) { expected_path == generated_path }
-        end
+        msg = build_message(message, "The generated path <?> did not match <?>", generated_path,
+            expected_path)
+        assert_block(msg) { expected_path == generated_path }
       end
 
       # Asserts that path and options match both ways; in other words, it verifies that <tt>path</tt> generates
@@ -107,7 +103,7 @@ module ActionController
       #  assert_routing '/home', :controller => 'home', :action => 'index'
       #
       #  # Test a route generated with a specific controller, action, and parameter (id)
-      #  assert_routing '/entries/show/23', :controller => 'entries', :action => 'show', id => 23
+      #  assert_routing '/entries/show/23', :controller => 'entries', :action => 'show', :id => 23
       #
       #  # Assert a basic route (controller + default action), with an error message if it fails
       #  assert_routing '/store', { :controller => 'store', :action => 'index' }, {}, {}, 'Route for store index not generated properly'
@@ -116,7 +112,7 @@ module ActionController
       #  assert_routing 'controller/action/9', {:id => "9", :item => "square"}, {:controller => "controller", :action => "action"}, {}, {:item => "square"}
       #
       #  # Tests a route with a HTTP method
-      #  assert_routing { :method => 'put', :path => '/product/321' }, { :controller => "product", :action => "update", :id => "321" }
+      #  assert_routing({ :method => 'put', :path => '/product/321' }, { :controller => "product", :action => "update", :id => "321" })
       def assert_routing(path, options, defaults={}, extras={}, message=nil)
         assert_recognizes(options, path, extras, message)
 
@@ -128,6 +124,46 @@ module ActionController
         assert_generates(path.is_a?(Hash) ? path[:path] : path, options, defaults, extras, message)
       end
 
+      # A helper to make it easier to test different route configurations.
+      # This method temporarily replaces ActionController::Routing::Routes
+      # with a new RouteSet instance.
+      #
+      # The new instance is yielded to the passed block. Typically the block
+      # will create some routes using <tt>map.draw { map.connect ... }</tt>:
+      #
+      #   with_routing do |set|
+      #     set.draw do |map|
+      #       map.connect ':controller/:action/:id'
+      #         assert_equal(
+      #           ['/content/10/show', {}],
+      #           map.generate(:controller => 'content', :id => 10, :action => 'show')
+      #       end
+      #     end
+      #   end
+      #
+      def with_routing
+        real_routes = ActionController::Routing::Routes
+        ActionController::Routing.module_eval { remove_const :Routes }
+
+        temporary_routes = ActionController::Routing::RouteSet.new
+        ActionController::Routing.module_eval { const_set :Routes, temporary_routes }
+
+        yield temporary_routes
+      ensure
+        if ActionController::Routing.const_defined? :Routes
+          ActionController::Routing.module_eval { remove_const :Routes }
+        end
+        ActionController::Routing.const_set(:Routes, real_routes) if real_routes
+      end
+
+      def method_missing(selector, *args, &block)
+        if @controller && ActionController::Routing::Routes.named_routes.helpers.include?(selector)
+          @controller.send(selector, *args, &block)
+        else
+          super
+        end
+      end
+
       private
         # Recognizes the route for a given path.
         def recognized_request_for(path, request_method = nil)
@@ -136,9 +172,11 @@ module ActionController
           # Assume given controller
           request = ActionController::TestRequest.new
           request.env["REQUEST_METHOD"] = request_method.to_s.upcase if request_method
-          request.path   = path
+          request.path = path
+
+          params = ActionController::Routing::Routes.recognize_path(path, { :method => request.method })
+          request.path_parameters = params.with_indifferent_access
 
-          ActionController::Routing::Routes.recognize(request)
           request
         end
     end

data/lib/{action_controller/assertions/selector_assertions.rb → action_dispatch/testing/assertions/selector.rb}

@@ -1,9 +1,11 @@
+require 'action_controller/vendor/html-scanner'
+
 #--
 # Copyright (c) 2006 Assaf Arkin (http://labnotes.org)
 # Under MIT and/or CC By license.
 #++
 
-module ActionController
+module ActionDispatch
   module Assertions
     unless const_defined?(:NO_STRIP)
       NO_STRIP = %w{pre script style textarea}
@@ -24,12 +26,6 @@ module ActionController
     #
     # Also see HTML::Selector to learn how to use selectors.
     module SelectorAssertions
-
-      def initialize(*args)
-        super
-        @selected = nil
-      end
-
       # :call-seq:
       #   css_select(selector) => array
       #   css_select(element, selector) => array
@@ -351,14 +347,17 @@ module ActionController
       #
       # Use the first argument to narrow down assertions to only statements
       # of that type. Possible values are <tt>:replace</tt>, <tt>:replace_html</tt>,
-      # <tt>:show</tt>, <tt>:hide</tt>, <tt>:toggle</tt>, <tt>:remove</tt> and
-      # <tt>:insert_html</tt>.
+      # <tt>:show</tt>, <tt>:hide</tt>, <tt>:toggle</tt>, <tt>:remove</tta>,
+      # <tt>:insert_html</tt> and <tt>:redirect</tt>.
       #
       # Use the argument <tt>:insert</tt> followed by an insertion position to narrow
       # down the assertion to only statements that insert elements in that
       # position. Possible values are <tt>:top</tt>, <tt>:bottom</tt>, <tt>:before</tt>
       # and <tt>:after</tt>.
       #
+      # Use the argument <tt>:redirect</tt> follwed by a path to check that an statement
+      # which redirects to the specified path is generated.
+      #
       # Using the <tt>:remove</tt> statement, you will be able to pass a block, but it will
       # be ignored as there is no HTML passed for this statement.
       #
@@ -405,6 +404,9 @@ module ActionController
       #
       #   # The same, but shorter.
       #   assert_select "ol>li", 4
+      #
+      #   # Checking for a redirect.
+      #   assert_select_rjs :redirect, root_path
       def assert_select_rjs(*args, &block)
         rjs_type = args.first.is_a?(Symbol) ? args.shift : nil
         id       = args.first.is_a?(String) ? args.shift : nil
@@ -522,7 +524,7 @@ module ActionController
 
         fix_content = lambda do |node|
           # Gets around a bug in the Rails 1.1 HTML parser.
-          node.content.gsub(/<!\[CDATA\[(.*)(\]\]>)?/m) { CGI.escapeHTML($1) }
+          node.content.gsub(/<!\[CDATA\[(.*)(\]\]>)?/m) { Rack::Utils.escapeHTML($1) }
         end
 
         selected = elements.map do |element|
@@ -582,7 +584,8 @@ module ActionController
             :chained_replace      => "\\$\\(#{RJS_ANY_ID}\\)\\.replace\\(#{RJS_PATTERN_HTML}\\)",
             :chained_replace_html => "\\$\\(#{RJS_ANY_ID}\\)\\.update\\(#{RJS_PATTERN_HTML}\\)",
             :replace_html         => "Element\\.update\\(#{RJS_ANY_ID}, #{RJS_PATTERN_HTML}\\)",
-            :replace              => "Element\\.replace\\(#{RJS_ANY_ID}, #{RJS_PATTERN_HTML}\\)"
+            :replace              => "Element\\.replace\\(#{RJS_ANY_ID}, #{RJS_PATTERN_HTML}\\)",
+            :redirect             => "window.location.href = #{RJS_ANY_ID}"
           }
           [:remove, :show, :hide, :toggle].each do |action|
             RJS_STATEMENTS[action] = "Element\\.#{action}\\(#{RJS_ANY_ID}\\)"