actionpack 1.12.5 → 1.13.0

data/lib/action_controller/{deprecated_assertions.rb → assertions/deprecated_assertions.rb}

@@ -1,38 +1,42 @@
-require 'test/unit'
-require 'test/unit/assertions'
 require 'rexml/document'
 
-module Test #:nodoc:
-  module Unit #:nodoc:
-    module Assertions
+module ActionController #:nodoc:
+  module Assertions #:nodoc:
+    module DeprecatedAssertions
       def assert_success(message=nil) #:nodoc:
         assert_response(:success, message)
       end
+      deprecate :assert_success => "use assert_response(:success)"
 
       def assert_redirect(message=nil) #:nodoc:
         assert_response(:redirect, message)
       end
+      deprecate :assert_redirect => "use assert_response(:redirect)"
 
       def assert_rendered_file(expected=nil, message=nil) #:nodoc:
         assert_template(expected, message)
       end
+      deprecate :assert_rendered_file => :assert_template
 
       # ensure that the session has an object with the specified name
       def assert_session_has(key=nil, message=nil) #:nodoc:
         msg = build_message(message, "<?> is not in the session <?>", key, @response.session)
         assert_block(msg) { @response.has_session_object?(key) }
       end
+      deprecate :assert_session_has => "use assert(@response.has_session_object?(key))"
 
       # ensure that the session has no object with the specified name
       def assert_session_has_no(key=nil, message=nil) #:nodoc:
         msg = build_message(message, "<?> is in the session <?>", key, @response.session)
         assert_block(msg) { !@response.has_session_object?(key) }
       end
+      deprecate :assert_session_has_no => "use assert(!@response.has_session_object?(key))"
 
       def assert_session_equal(expected = nil, key = nil, message = nil) #:nodoc:
         msg = build_message(message, "<?> expected in session['?'] but was <?>", expected, key, @response.session[key])
         assert_block(msg) { expected == @response.session[key] }
       end
+      deprecate :assert_session_equal => "use assert_equal(expected, @response[key])"
 
       # -- cookie assertions ---------------------------------------------------
 
@@ -41,6 +45,7 @@ module Test #:nodoc:
         msg = build_message(message, "<?> not expected in cookies['?']", actual, key)
         assert_block(msg) { actual.nil? or actual.empty? }
       end
+      deprecate :assert_no_cookie => "use assert(!@response.cookies.key?(key))"
     
       def assert_cookie_equal(expected = nil, key = nil, message = nil) #:nodoc:
         actual = @response.cookies[key]
@@ -48,6 +53,7 @@ module Test #:nodoc:
         msg = build_message(message, "<?> expected in cookies['?'] but was <?>", expected, key, actual)
         assert_block(msg) { expected == actual }
       end
+      deprecate :assert_cookie_equal => "use assert(@response.cookies.key?(key))"
     
       # -- flash assertions ---------------------------------------------------
 
@@ -56,41 +62,48 @@ module Test #:nodoc:
         msg = build_message(message, "<?> is not in the flash <?>", key, @response.flash)
         assert_block(msg) { @response.has_flash_object?(key) }
       end
+      deprecate :assert_flash_has => "use assert(@response.has_flash_object?(key))"
 
       # ensure that the flash has no object with the specified name
       def assert_flash_has_no(key=nil, message=nil) #:nodoc:
         msg = build_message(message, "<?> is in the flash <?>", key, @response.flash)
         assert_block(msg) { !@response.has_flash_object?(key) }
       end
+      deprecate :assert_flash_has_no => "use assert(!@response.has_flash_object?(key))"
 
       # ensure the flash exists
       def assert_flash_exists(message=nil) #:nodoc:
         msg = build_message(message, "the flash does not exist <?>", @response.session['flash'] )
         assert_block(msg) { @response.has_flash? }
       end
+      deprecate :assert_flash_exists => "use assert(@response.has_flash?)"
 
       # ensure the flash does not exist
       def assert_flash_not_exists(message=nil) #:nodoc:
         msg = build_message(message, "the flash exists <?>", @response.flash)
         assert_block(msg) { !@response.has_flash? }
       end
+      deprecate :assert_flash_not_exists => "use assert(!@response.has_flash?)"
     
       # ensure the flash is empty but existent
       def assert_flash_empty(message=nil) #:nodoc:
         msg = build_message(message, "the flash is not empty <?>", @response.flash)
         assert_block(msg) { !@response.has_flash_with_contents? }
       end
+      deprecate :assert_flash_empty => "use assert(!@response.has_flash_with_contents?)"
 
       # ensure the flash is not empty
       def assert_flash_not_empty(message=nil) #:nodoc:
         msg = build_message(message, "the flash is empty")
         assert_block(msg) { @response.has_flash_with_contents? }
       end
+      deprecate :assert_flash_not_empty => "use assert(@response.has_flash_with_contents?)"
     
       def assert_flash_equal(expected = nil, key = nil, message = nil) #:nodoc:
         msg = build_message(message, "<?> expected in flash['?'] but was <?>", expected, key, @response.flash[key])
         assert_block(msg) { expected == @response.flash[key] }
       end
+      deprecate :assert_flash_equal => "use assert_equal(expected, @response.flash[key])"
     
 
       # ensure our redirection url is an exact match
@@ -99,6 +112,7 @@ module Test #:nodoc:
         msg = build_message(message, "<?> is not the redirected location <?>", url, @response.redirect_url)
         assert_block(msg) { @response.redirect_url == url }
       end
+      deprecate :assert_redirect_url => "use assert_equal(url, @response.redirect_url)"
 
       # ensure our redirection url matches a pattern
       def assert_redirect_url_match(pattern=nil, message=nil) #:nodoc:
@@ -106,6 +120,7 @@ module Test #:nodoc:
         msg = build_message(message, "<?> was not found in the location: <?>", pattern, @response.redirect_url)
         assert_block(msg) { @response.redirect_url_match?(pattern) }
       end
+      deprecate :assert_redirect_url_match => "use assert(@response.redirect_url_match?(pattern))"
 
     
       # -- template assertions ------------------------------------------------
@@ -115,12 +130,14 @@ module Test #:nodoc:
         msg = build_message(message, "<?> is not a template object", key )
         assert_block(msg) { @response.has_template_object?(key) }
       end
+      deprecate :assert_template_has => "use assert(@response.has_template_object?(key))"
 
       # ensure that a template object with the given name does not exist
       def assert_template_has_no(key=nil,message=nil) #:nodoc:
         msg = build_message(message, "<?> is a template object <?>", key, @response.template_objects[key])
         assert_block(msg) { !@response.has_template_object?(key) }
       end
+      deprecate :assert_template_has_no => "use assert(!@response.has_template_object?(key))"
 
       # ensures that the object assigned to the template on +key+ is equal to +expected+ object.
       def assert_template_equal(expected = nil, key = nil, message = nil) #:nodoc:
@@ -128,6 +145,8 @@ module Test #:nodoc:
         assert_block(msg) { expected == @response.template.assigns[key.to_s] }
       end
       alias_method :assert_assigned_equal, :assert_template_equal
+      deprecate :assert_assigned_equal => "use assert_equal(expected, @response.template.assigns[key.to_s])"
+      deprecate :assert_template_equal => "use assert_equal(expected, @response.template.assigns[key.to_s])"
 
       # Asserts that the template returns the +expected+ string or array based on the XPath +expression+.
       # This will only work if the template rendered a valid XML document.
@@ -145,6 +164,7 @@ module Test #:nodoc:
         msg = build_message(message, "<?> found <?>, not <?>", expression, matches, expected)
         assert_block(msg) { matches == expected }
       end
+      deprecate :assert_template_xpath_match => "you should use assert_tag, instead"
 
       # Assert the template object with the given name is an Active Record descendant and is valid.
       def assert_valid_record(key = nil, message = nil) #:nodoc:
@@ -152,6 +172,7 @@ module Test #:nodoc:
         msg = build_message(message, "Active Record is invalid <?>)", record.errors.full_messages)
         assert_block(msg) { record.valid? }
       end
+      deprecate :assert_valid_record => "use assert(assigns(key).valid?)"
 
       # Assert the template object with the given name is an Active Record descendant and is invalid.
       def assert_invalid_record(key = nil, message = nil) #:nodoc:
@@ -159,6 +180,7 @@ module Test #:nodoc:
         msg = build_message(message, "Active Record is valid)")
         assert_block(msg) { !record.valid? }
       end
+      deprecate :assert_invalid_record => "use assert(!assigns(key).valid?)"
 
       # Assert the template object with the given name is an Active Record descendant and the specified column(s) are valid.
       def assert_valid_column_on_record(key = nil, columns = "", message = nil) #:nodoc:
@@ -170,6 +192,7 @@ module Test #:nodoc:
         msg = build_message(message, "Active Record has invalid columns <?>)", cols.join(",") )
         assert_block(msg) { cols.empty? }
       end
+      deprecate :assert_valid_column_on_record => "use assert(!record.errors.invalid?(column)) instead"
 
       # Assert the template object with the given name is an Active Record descendant and the specified column(s) are invalid.
       def assert_invalid_column_on_record(key = nil, columns = "", message = nil) #:nodoc:
@@ -181,6 +204,7 @@ module Test #:nodoc:
         msg = build_message(message, "Active Record has valid columns <?>)", cols.join(",") )
         assert_block(msg) { cols.empty? }
       end
+      deprecate :assert_invalid_column_on_record => "use assert(record.errors.invalid?(column)) instead"
 
       private
         def glue_columns(columns)
@@ -191,14 +215,14 @@ module Test #:nodoc:
         end
 
         def find_record_in_template(key = nil)
-          assert_template_has(key)
+          assert_not_nil assigns(key)
           record = @response.template_objects[key]
 
           assert_not_nil(record)
           assert_kind_of ActiveRecord::Base, record
 
           return record
-        end      
+        end
     end
   end
-end
+end

data/lib/action_controller/assertions/dom_assertions.rb

@@ -0,0 +1,25 @@
+module ActionController
+  module Assertions
+    module DomAssertions
+      # test 2 html strings to be equivalent, i.e. identical up to reordering of attributes
+      def assert_dom_equal(expected, actual, message="")
+        clean_backtrace do
+          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
+      
+      # negated form of +assert_dom_equivalent+
+      def assert_dom_not_equal(expected, actual, message="")
+        clean_backtrace do
+          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
+end

data/lib/action_controller/assertions/model_assertions.rb

@@ -0,0 +1,12 @@
+module ActionController
+  module Assertions
+    module ModelAssertions
+      # ensures that the passed record is valid by active record standards. returns the error messages if not
+      def assert_valid(record)
+        clean_backtrace do
+          assert record.valid?, record.errors.full_messages.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/action_controller/assertions/response_assertions.rb

@@ -0,0 +1,140 @@
+require 'rexml/document'
+require File.dirname(__FILE__) + "/../vendor/html-scanner/html/document"
+
+module ActionController
+  module Assertions
+    module ResponseAssertions
+      # 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 ActionController::StatusCodes for a full list.
+      def assert_response(type, message = nil)
+        clean_backtrace do
+          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 == ActionController::StatusCodes::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
+      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.
+      def assert_redirected_to(options = {}, message=nil)
+        clean_backtrace do
+          assert_response(:redirect, message)
+          return true if options == @response.redirected_to
+          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+
+          begin
+            url  = {}
+            original = { :expected => options, :actual => @response.redirected_to.is_a?(Symbol) ? @response.redirected_to : @response.redirected_to.dup }
+            original.each do |key, value|
+              if value.is_a?(Symbol)
+                value = @controller.respond_to?(value, true) ? @controller.send(value) : @controller.send("hash_for_#{value}_url")
+              end
+
+              unless value.is_a?(Hash)
+                request = case value
+                  when NilClass    then nil
+                  when /^\w+:\/\// then recognized_request_for(%r{^(\w+://.*?(/|$|\?))(.*)$} =~ value ? $3 : nil)
+                  else                  recognized_request_for(value)
+                end
+                value = request.path_parameters if request
+              end
+
+              if value.is_a?(Hash) # stringify 2 levels of hash keys
+                if name = value.delete(:use_route)
+                  route = ActionController::Routing::Routes.named_routes[name]
+                  value.update(route.parameter_shell)
+                end
+
+                value.stringify_keys!
+                value.values.select { |v| v.is_a?(Hash) }.collect { |v| v.stringify_keys! }
+                if key == :expected && value['controller'] == @controller.controller_name && original[:actual].is_a?(Hash)
+                  original[:actual].stringify_keys!
+                  value.delete('controller') if original[:actual]['controller'].nil? || original[:actual]['controller'] == value['controller']
+                end
+              end
+
+              if value.respond_to?(:[]) && value['controller']
+                if key == :actual && value['controller'].first != '/' && !value['controller'].include?('/')
+                  new_controller_path = ActionController::Routing.controller_relative_to(value['controller'], @controller.class.controller_path)
+                  value['controller'] = new_controller_path if value['controller'] != new_controller_path && ActionController::Routing.possible_controllers.include?(new_controller_path)
+                end
+                value['controller'] = value['controller'][1..-1] if value['controller'].first == '/' # strip leading hash
+              end
+              url[key] = value
+            end
+
+
+            @response_diff = url[:expected].diff(url[:actual]) if url[:actual]
+            msg = build_message(message, "response is not a redirection to all of the options supplied (redirection is <?>), difference: <?>",
+                                url[:actual], @response_diff)
+
+            assert_block(msg) do
+              url[:expected].keys.all? do |k|
+                if k == :controller then url[:expected][k] == ActionController::Routing.controller_relative_to(url[:actual][k], @controller.class.controller_path)
+                else parameterize(url[:expected][k]) == parameterize(url[:actual][k])
+                end
+              end
+            end
+          rescue ActionController::RoutingError # routing failed us, so match the strings only.
+            msg = build_message(message, "expected a redirect to <?>, found one to <?>", options, @response.redirect_url)
+            url_regexp = %r{^(\w+://.*?(/|$|\?))(.*)$}
+            eurl, epath, url, path = [options, @response.redirect_url].collect do |url|
+              u, p = (url_regexp =~ url) ? [$1, $3] : [nil, url]
+              [u, (p.first == '/') ? p : '/' + p]
+            end.flatten
+
+            assert_equal(eurl, url, msg) if eurl && url
+            assert_equal(epath, path, msg) if epath && path
+          end
+        end
+      end
+
+      # Asserts that the request was rendered with the appropriate template file.
+      def assert_template(expected = nil, message=nil)
+        clean_backtrace do
+          rendered = expected ? @response.rendered_file(!expected.include?('/')) : @response.rendered_file
+          msg = build_message(message, "expecting <?> but rendering with <?>", expected, rendered)
+          assert_block(msg) do
+            if expected.nil?
+              !@response.rendered_with_file?
+            else
+              expected == rendered
+            end
+          end
+        end
+      end
+
+      private
+        def recognized_request_for(path, request_method = nil)
+          path = "/#{path}" unless path.first == '/'
+
+          # Assume given controller
+          request = ActionController::TestRequest.new({}, {}, nil)
+          request.env["REQUEST_METHOD"] = request_method.to_s.upcase if request_method
+          request.path   = path
+
+          ActionController::Routing::Routes.recognize(request)
+          request
+        end
+
+        def parameterize(value)
+          value.respond_to?(:to_param) ? value.to_param : value
+        end
+    end
+  end
+end

data/lib/action_controller/assertions/routing_assertions.rb

@@ -0,0 +1,82 @@
+module ActionController
+  module Assertions
+    module RoutingAssertions
+      # Asserts that the routing of the given path was handled correctly and that the parsed options match.
+      #
+      #   assert_recognizes({:controller => 'items', :action => 'index'}, 'items')
+      #
+      # Pass a hash in the second argument to specify the request method.  This is useful for routes
+      # requiring a specific method.
+      #
+      #   assert_recognizes({:controller => 'items', :action => 'create'}, {:path => 'items', :method => :post})
+      #
+      def assert_recognizes(expected_options, path, extras={}, message=nil)
+        if path.is_a? Hash
+          request_method = path[:method]
+          path           = path[:path]
+        else
+          request_method = nil
+        end
+
+        clean_backtrace do 
+          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty? 
+          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.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
+      end
+
+      # Asserts that the provided options can be used to generate the provided path.
+      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? 
+      
+          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, "The generated path <?> did not match <?>", generated_path, 
+              expected_path)
+          assert_block(msg) { expected_path == generated_path }
+        end
+      end
+
+      # Asserts that path and options match both ways; in other words, the URL generated from 
+      # options is the same as path, and also that the options recognized from path are the same as options
+      def assert_routing(path, options, defaults={}, extras={}, message=nil)
+        assert_recognizes(options, path, extras, message)
+        
+        controller, default_controller = options[:controller], defaults[:controller] 
+        if controller && controller.include?(?/) && default_controller && default_controller.include?(?/)
+          options[:controller] = "/#{controller}"
+        end
+         
+        assert_generates(path, options, defaults, extras, message)
+      end
+
+      private
+        def recognized_request_for(path, request_method = nil)
+          path = "/#{path}" unless path.first == '/'
+
+          # Assume given controller
+          request = ActionController::TestRequest.new({}, {}, nil)
+          request.env["REQUEST_METHOD"] = request_method.to_s.upcase if request_method
+          request.path   = path
+
+          ActionController::Routing::Routes.recognize(request)
+          request
+        end
+    end
+  end
+end