Deprecated the majority of all the testing assertions and replaced them with a...

Deprecated the majority of all the testing assertions and replaced them with a much smaller core and access to all the collections the old assertions relied on. That way the regular test/unit assertions can be used against these. Added documentation about how to use it all.

git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@1189 5ecf4fe2-1ee6-0310-87b1-e25e094e27de

actionpack/CHANGELOG

 *SVN*
 
+* Deprecated the majority of all the testing assertions and replaced them with a much smaller core and access to all the collections the old assertions relied on. That way the regular test/unit assertions can be used against these. Added documentation about how to use it all.
+
 * Fixed DateHelper to return values on the option tags such that they'll work properly in IE with form_remote_tag #1024 [rscottmace@gmail.com]
 
 * Fixed FormTagHelper#check_box to respect checked #1049 [DelynnB]

actionpack/lib/action_controller/assertions.rb

+require 'test/unit'
+require 'test/unit/assertions'
+require 'rexml/document'
+
+module Test #:nodoc:
+  module Unit #:nodoc:
+    # In addition to these specific assertions, you also have easy access to various collections that the regular test/unit assertions
+    # can be used against. These collections are:
+    #
+    # * assigns: Instance variables assigned in the action that's available for the view.
+    # * session: Objects being saved in the session.
+    # * flash: The flash objects being currently in the session.
+    # * cookies: Cookies being sent to the user on this request.
+    # 
+    # These collections can be used just like any other hash:
+    #
+    #   assert_not_nil assigns[:person] # makes sure that a @person instance variable was set
+    #   assert_equal "Dave", cookies[:name] # makes sure that a cookie called :name was set as "Dave"
+    #   assert flash.empty? # makes sure that there's nothing in the flash
+    #
+    # On top of the collections, you have the complete url that a given action redirected to available in redirect_to_url.
+    #
+    # For redirects within the same controller, you can even call follow_redirect and the redirect will be follow triggering another
+    # action call which can then be asserted against.
+    module Assertions
+      # 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 code number as the type, like assert_response(501)
+      def assert_response(type, message = nil)
+        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
+        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 at 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)
+        assert_redirect(message)
+
+        msg = build_message(message, "response is not a redirection to all of the options supplied (redirection is <?>)", @response.redirected_to)
+        assert_block(msg) do
+          if options.is_a?(Symbol)
+            @response.redirected_to == options
+          else
+            options.keys.all? do |k| 
+              options[k] == (@response.redirected_to[k].respond_to?(:to_param) ? @response.redirected_to[k].to_param : @response.redirected_to[k] if @response.redirected_to[k])
+            end
+          end
+        end
+      end
+
+      # Asserts that the request was rendered with the appropriate template file
+      def assert_template(expected=nil, message=nil)
+        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
+
+      alias_method :assert_rendered_file, :assert_template #:nodoc:
+      
+      # -- routing assertions --------------------------------------------------
+
+      # Asserts that the routing of the given path is handled correctly and that the parsed options match.
+      def assert_recognizes(expected_options, path, extras={}, message=nil)
+        # Load routes.rb if it hasn't been loaded.
+        ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty? 
+      
+        # Assume given controller
+        request = ActionController::TestRequest.new({}, {}, nil)
+        request.path = path
+        ActionController::Routing::Routes.recognize!(request)
+      
+        expected_options = expected_options.clone
+        extras.each_key { |key| expected_options.delete key } unless extras.nil?
+      
+        msg = build_message(message, "The recognized options <?> did not match <?>", 
+            request.path_parameters, expected_options)
+        assert_block(msg) { request.path_parameters == expected_options }
+      end
+
+      # Asserts that the provided options can be used to generate the provided path.
+      def assert_generates(expected_path, options, defaults={}, extras = {}, message=nil)
+        # Load routes.rb if it hasn't been loaded.
+        ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty? 
+      
+        # Assume given controller
+        request = ActionController::TestRequest.new({}, {}, nil)
+        request.path_parameters = (defaults or {}).clone
+        request.path_parameters[:controller] ||= options[:controller]
+      
+        generated_path, found_extras = ActionController::Routing::Routes.generate(options, request)
+        generated_path = generated_path.join('/')
+        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
+
+      # asserts that path and options match both ways, in other words, the URL generated from 
+      # options is same as path, and also that the options recognized from path are same as options
+      def assert_routing(path, options, defaults={}, extras={}, message=nil)
+        assert_recognizes(options, path, extras, message)
+        assert_generates(path, options, defaults, extras, message)
+      end
+    end
+  end
+end
\ No newline at end of file

actionpack/lib/action_controller/assertions/active_record_assertions.rb

-require 'test/unit'
-require 'test/unit/assertions'
-# active_record is assumed to be loaded by this point
-
-module Test #:nodoc:
-  module Unit #:nodoc:
-    module Assertions
-      # Assert the template object with the given name is an Active Record descendant and is valid.
-      def assert_valid_record(key = nil, message = nil)
-        record = find_record_in_template(key)
-        msg = build_message(message, "Active Record is invalid <?>)", record.errors.full_messages)
-        assert_block(msg) { record.valid? }
-      end
-
-      # Assert the template object with the given name is an Active Record descendant and is invalid.
-      def assert_invalid_record(key = nil, message = nil)
-        record = find_record_in_template(key)
-        msg = build_message(message, "Active Record is valid)")
-        assert_block(msg) { !record.valid? }
-      end
-
-      # 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)
-        record = find_record_in_template(key)
-        record.send(:validate)
-
-        cols = glue_columns(columns)
-        cols.delete_if { |col| !record.errors.invalid?(col) }
-        msg = build_message(message, "Active Record has invalid columns <?>)", cols.join(",") )
-        assert_block(msg) { cols.empty? }
-      end
-
-      # 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)
-        record = find_record_in_template(key)
-        record.send(:validate)
-
-        cols = glue_columns(columns)
-        cols.delete_if { |col| record.errors.invalid?(col) }
-        msg = build_message(message, "Active Record has valid columns <?>)", cols.join(",") )
-        assert_block(msg) { cols.empty? }
-      end
-      
-      private
-        def glue_columns(columns)
-          cols = []
-          cols << columns if columns.class == String
-          cols += columns if columns.class == Array
-          cols
-        end
-      
-        def find_record_in_template(key = nil)
-          response = acquire_assertion_target
-
-          assert_template_has(key)
-          record = response.template_objects[key]
-
-          assert_not_nil(record)
-          assert_kind_of ActiveRecord::Base, record
-
-          return record
-        end      
-    end
-  end
-end
\ No newline at end of file

actionpack/lib/action_controller/assertions/action_pack_assertions.rb → actionpack/lib/action_controller/deprecated_assertions.rb

@@ -4,244 +4,131 @@
 
 module Test #:nodoc:
   module Unit #:nodoc:
-    # Adds a wealth of assertions to do functional testing of Action Controllers.
-    module Assertions
-      # -- basic assertions ---------------------------------------------------
-      
-      # ensure that the web request has been serviced correctly
+    module Assertions #:nodoc:
       def assert_success(message=nil)
-        response = acquire_assertion_target
-        if response.success?
-          # to count the assertion
-          assert_block("") { true }
-        else
-          if response.redirect?
-            msg = build_message(message, "Response unexpectedly redirect to <?>", response.redirect_url)
-          else
-            msg = build_message(message, "unsuccessful request (response code = <?>)", 
-                response.response_code)
-          end
-          assert_block(msg) { false }
-        end
+        assert_response(:success, message)
       end
 
-      # ensure the request was rendered with the appropriate template file
-      def assert_rendered_file(expected=nil, message=nil)
-        response = acquire_assertion_target
-        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
+      def assert_redirect(message=nil)
+        assert_response(:redirect, message)
       end
-      
-      # -- session assertions -------------------------------------------------
 
       # ensure that the session has an object with the specified name
       def assert_session_has(key=nil, message=nil)
-        response = acquire_assertion_target
-        msg = build_message(message, "<?> is not in the session <?>", key, response.session)
-        assert_block(msg) { response.has_session_object?(key) }
+        msg = build_message(message, "<?> is not in the session <?>", key, @response.session)
+        assert_block(msg) { @response.has_session_object?(key) }
       end
 
       # ensure that the session has no object with the specified name
       def assert_session_has_no(key=nil, message=nil)
-        response = acquire_assertion_target
-        msg = build_message(message, "<?> is in the session <?>", key, response.session)
-        assert_block(msg) { !response.has_session_object?(key) }
+        msg = build_message(message, "<?> is in the session <?>", key, @response.session)
+        assert_block(msg) { !@response.has_session_object?(key) }
       end
-      
+
       def assert_session_equal(expected = nil, key = nil, message = nil)
-        response = acquire_assertion_target
-        msg = build_message(message, "<?> expected in session['?'] but was <?>", expected, key, response.session[key])
-        assert_block(msg) { expected == response.session[key] }
+        msg = build_message(message, "<?> expected in session['?'] but was <?>", expected, key, @response.session[key])
+        assert_block(msg) { expected == @response.session[key] }
       end
 
       # -- cookie assertions ---------------------------------------------------
 
       def assert_no_cookie(key = nil, message = nil)
-        response = acquire_assertion_target
-        actual = response.cookies[key]
+        actual = @response.cookies[key]
         msg = build_message(message, "<?> not expected in cookies['?']", actual, key)
         assert_block(msg) { actual.nil? or actual.empty? }
       end
-      
+    
       def assert_cookie_equal(expected = nil, key = nil, message = nil)
-        response = acquire_assertion_target
-        actual = response.cookies[key]
+        actual = @response.cookies[key]
         actual = actual.first if actual
         msg = build_message(message, "<?> expected in cookies['?'] but was <?>", expected, key, actual)
         assert_block(msg) { expected == actual }
       end
-      
+    
       # -- flash assertions ---------------------------------------------------
 
       # ensure that the flash has an object with the specified name
       def assert_flash_has(key=nil, message=nil)
-        response = acquire_assertion_target
-        msg = build_message(message, "<?> is not in the flash <?>", key, response.flash)
-        assert_block(msg) { response.has_flash_object?(key) }
+        msg = build_message(message, "<?> is not in the flash <?>", key, @response.flash)
+        assert_block(msg) { @response.has_flash_object?(key) }
       end
 
       # ensure that the flash has no object with the specified name
       def assert_flash_has_no(key=nil, message=nil)
-        response = acquire_assertion_target
-        msg = build_message(message, "<?> is in the flash <?>", key, response.flash)
-        assert_block(msg) { !response.has_flash_object?(key) }
+        msg = build_message(message, "<?> is in the flash <?>", key, @response.flash)
+        assert_block(msg) { !@response.has_flash_object?(key) }
       end
 
       # ensure the flash exists
       def assert_flash_exists(message=nil)
-        response = acquire_assertion_target
-        msg = build_message(message, "the flash does not exist <?>", response.session['flash'] )
-        assert_block(msg) { response.has_flash? }
+        msg = build_message(message, "the flash does not exist <?>", @response.session['flash'] )
+        assert_block(msg) { @response.has_flash? }
       end
 
       # ensure the flash does not exist
       def assert_flash_not_exists(message=nil)
-        response = acquire_assertion_target
-        msg = build_message(message, "the flash exists <?>", response.flash)
-        assert_block(msg) { !response.has_flash? }
+        msg = build_message(message, "the flash exists <?>", @response.flash)
+        assert_block(msg) { !@response.has_flash? }
       end
-      
+    
       # ensure the flash is empty but existent
       def assert_flash_empty(message=nil)
-        response = acquire_assertion_target
-        msg = build_message(message, "the flash is not empty <?>", response.flash)
-        assert_block(msg) { !response.has_flash_with_contents? }
+        msg = build_message(message, "the flash is not empty <?>", @response.flash)
+        assert_block(msg) { !@response.has_flash_with_contents? }
       end
 
       # ensure the flash is not empty
       def assert_flash_not_empty(message=nil)
-        response = acquire_assertion_target
         msg = build_message(message, "the flash is empty")
-        assert_block(msg) { response.has_flash_with_contents? }
+        assert_block(msg) { @response.has_flash_with_contents? }
       end
-      
+    
       def assert_flash_equal(expected = nil, key = nil, message = nil)
-        response = acquire_assertion_target
-        msg = build_message(message, "<?> expected in flash['?'] but was <?>", expected, key, response.flash[key])
-        assert_block(msg) { expected == response.flash[key] }
+        msg = build_message(message, "<?> expected in flash['?'] but was <?>", expected, key, @response.flash[key])
+        assert_block(msg) { expected == @response.flash[key] }
       end
-      
-      # -- redirection assertions ---------------------------------------------
-
-      # ensure we have be redirected
-      def assert_redirect(message=nil)
-        response = acquire_assertion_target
-        msg = build_message(message, "response is not a redirection (response code is <?>)", response.response_code)
-        assert_block(msg) { response.redirect? }
-      end
-
-      def assert_redirected_to(options = {}, message=nil)
-        assert_redirect(message)
-        response = acquire_assertion_target
+    
 
-        msg = build_message(message, "response is not a redirection to all of the options supplied (redirection is <?>)", response.redirected_to)
-        assert_block(msg) do
-          if options.is_a?(Symbol)
-            response.redirected_to == options
-          else
-            options.keys.all? { |k| options[k] == ( response.redirected_to[k].respond_to?(:to_param) ? response.redirected_to[k].to_param : response.redirected_to[k] if response.redirected_to[k] ) }
-          end
-        end
-      end
-      
       # ensure our redirection url is an exact match
       def assert_redirect_url(url=nil, message=nil)
         assert_redirect(message)
-        response = acquire_assertion_target
-        msg = build_message(message, "<?> is not the redirected location <?>", url, response.redirect_url)
-        assert_block(msg) { response.redirect_url == url }
+        msg = build_message(message, "<?> is not the redirected location <?>", url, @response.redirect_url)
+        assert_block(msg) { @response.redirect_url == url }
       end
 
       # ensure our redirection url matches a pattern
       def assert_redirect_url_match(pattern=nil, message=nil)
         assert_redirect(message)
-        response = acquire_assertion_target
-        msg = build_message(message, "<?> was not found in the location: <?>", pattern, response.redirect_url)
-        assert_block(msg) { response.redirect_url_match?(pattern) }
-      end
-
-      # -- routing assertions --------------------------------------------------
-
-      # Asserts that the routing of the given path is handled correctly and that the parsed options match.
-      def assert_recognizes(expected_options, path, extras={}, message=nil)
-        # Load routes.rb if it hasn't been loaded.
-        ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty? 
-        
-        # Assume given controller
-        request = ActionController::TestRequest.new({}, {}, nil)
-        request.path = path
-        ActionController::Routing::Routes.recognize!(request)
-        
-        expected_options = expected_options.clone
-        extras.each_key { |key| expected_options.delete key } unless extras.nil?
-        
-        msg = build_message(message, "The recognized options <?> did not match <?>", 
-            request.path_parameters, expected_options)
-        assert_block(msg) { request.path_parameters == expected_options }
-      end
-
-      # Asserts that the provided options can be used to generate the provided path.
-      def assert_generates(expected_path, options, defaults={}, extras = {}, message=nil)
-        # Load routes.rb if it hasn't been loaded.
-        ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty? 
-        
-        # Assume given controller
-        request = ActionController::TestRequest.new({}, {}, nil)
-        request.path_parameters = (defaults or {}).clone
-        request.path_parameters[:controller] ||= options[:controller]
-        
-        generated_path, found_extras = ActionController::Routing::Routes.generate(options, request)
-        generated_path = generated_path.join('/')
-        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 }
+        msg = build_message(message, "<?> was not found in the location: <?>", pattern, @response.redirect_url)
+        assert_block(msg) { @response.redirect_url_match?(pattern) }
       end
 
-      # asserts that path and options match both ways, in other words, the URL generated from 
-      # options is same as path, and also that the options recognized from path are same as options
-      def assert_routing(path, options, defaults={}, extras={}, message=nil)
-        assert_recognizes(options, path, extras, message)
-        assert_generates(path, options, defaults, extras, message)
-      end
-      
+    
       # -- template assertions ------------------------------------------------
 
       # ensure that a template object with the given name exists
       def assert_template_has(key=nil, message=nil)
-        response = acquire_assertion_target
         msg = build_message(message, "<?> is not a template object", key )
-        assert_block(msg) { response.has_template_object?(key) }
+        assert_block(msg) { @response.has_template_object?(key) }
       end
 
       # ensure that a template object with the given name does not exist
       def assert_template_has_no(key=nil,message=nil)
-        response = acquire_assertion_target
-        msg = build_message(message, "<?> is a template object <?>", key, response.template_objects[key])
-        assert_block(msg) { !response.has_template_object?(key) }
+        msg = build_message(message, "<?> is a template object <?>", key, @response.template_objects[key])
+        assert_block(msg) { !@response.has_template_object?(key) }
       end
 
       # ensures that the object assigned to the template on +key+ is equal to +expected+ object.
-      def assert_assigned_equal(expected = nil, key = nil, message = nil)
-        response = acquire_assertion_target
-        msg = build_message(message, "<?> expected in assigns['?'] but was <?>", expected, key, response.template.assigns[key.to_s])
-        assert_block(msg) { expected == response.template.assigns[key.to_s] }
+      def assert_template_equal(expected = nil, key = nil, message = nil)
+        msg = build_message(message, "<?> expected in assigns['?'] but was <?>", expected, key, @response.template.assigns[key.to_s])
+        assert_block(msg) { expected == @response.template.assigns[key.to_s] }
       end
+      alias_method :assert_assigned_equal, :assert_template_equal
 
       # 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.
       def assert_template_xpath_match(expression=nil, expected=nil, message=nil)
-        response = acquire_assertion_target
-        xml, matches = REXML::Document.new(response.body), []
+        xml, matches = REXML::Document.new(@response.body), []
         xml.elements.each(expression) { |e| matches << e.text }
         if matches.empty? then
           msg = build_message(message, "<?> not found in document", expression)
@@ -254,16 +141,60 @@ def assert_template_xpath_match(expression=nil, expected=nil, message=nil)
         msg = build_message(message, "<?> found <?>, not <?>", expression, matches, expected)
         assert_block(msg) { matches == expected }
       end
-      
-      # -- helper functions ---------------------------------------------------
-       
-      # get the TestResponse object that these assertions depend upon 
-      def acquire_assertion_target
-        target = ActionController::TestResponse.assertion_target
-        assert_block( "Unable to acquire the TestResponse.assertion_target.  Please set this before calling this assertion." ) { !target.nil? }
-        target
+
+      # Assert the template object with the given name is an Active Record descendant and is valid.
+      def assert_valid_record(key = nil, message = nil)
+        record = find_record_in_template(key)
+        msg = build_message(message, "Active Record is invalid <?>)", record.errors.full_messages)
+        assert_block(msg) { record.valid? }
+      end
+
+      # Assert the template object with the given name is an Active Record descendant and is invalid.
+      def assert_invalid_record(key = nil, message = nil)
+        record = find_record_in_template(key)
+        msg = build_message(message, "Active Record is valid)")
+        assert_block(msg) { !record.valid? }
+      end
+
+      # 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)
+        record = find_record_in_template(key)
+        record.send(:validate)
+
+        cols = glue_columns(columns)
+        cols.delete_if { |col| !record.errors.invalid?(col) }
+        msg = build_message(message, "Active Record has invalid columns <?>)", cols.join(",") )
+        assert_block(msg) { cols.empty? }
       end
-      
-    end # Assertions
-  end # Unit
-end # Test
+
+      # 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)
+        record = find_record_in_template(key)
+        record.send(:validate)
+
+        cols = glue_columns(columns)
+        cols.delete_if { |col| record.errors.invalid?(col) }
+        msg = build_message(message, "Active Record has valid columns <?>)", cols.join(",") )
+        assert_block(msg) { cols.empty? }
+      end
+
+      private
+        def glue_columns(columns)
+          cols = []
+          cols << columns if columns.class == String
+          cols += columns if columns.class == Array
+          cols
+        end
+
+        def find_record_in_template(key = nil)
+          assert_template_has(key)
+          record = @response.template_objects[key]
+
+          assert_not_nil(record)
+          assert_kind_of ActiveRecord::Base, record
+
+          return record
+        end      
+    end
+  end
+end
\ No newline at end of file

actionpack/lib/action_controller/flash.rb

@@ -24,7 +24,6 @@ module ActionController #:nodoc:
   #
   # See docs on the FlashHash class for more details about the flash.
   module Flash
-
     def self.append_features(base) #:nodoc:
       super
       base.before_filter(:fire_flash)
@@ -44,7 +43,6 @@ def []=(k, v)
     end
     
     class FlashHash < Hash
-    
       def initialize #:nodoc:
         super
         @used = {}
@@ -113,49 +111,45 @@ def sweep #:nodoc:
       end
     
       private
-    
-      # Used internally by the <tt>keep</tt> and <tt>discard</tt> methods
-      #     use()               # marks the entire flash as used
-      #     use('msg')          # marks the "msg" entry as used
-      #     use(nil, false)     # marks the entire flash as unused (keeps it around for one more action)
-      #     use('msg', false)   # marks the "msg" entry as unused (keeps it around for one more action)
-      def use(k=nil, v=true)
-        unless k.nil?
-          @used[k] = v
-        else
-          keys.each{|key| use key, v }
+        # Used internally by the <tt>keep</tt> and <tt>discard</tt> methods
+        #     use()               # marks the entire flash as used
+        #     use('msg')          # marks the "msg" entry as used
+        #     use(nil, false)     # marks the entire flash as unused (keeps it around for one more action)
+        #     use('msg', false)   # marks the "msg" entry as unused (keeps it around for one more action)
+        def use(k=nil, v=true)
+          unless k.nil?
+            @used[k] = v
+          else
+            keys.each{|key| use key, v }
+          end
         end
-      end
-
     end
      
    
     protected 
+      # Access the contents of the flash. Use <tt>flash["notice"]</tt> to read a notice you put there or 
+      # <tt>flash["notice"] = "hello"</tt> to put a new one.
+      def flash #:doc:
+        @session['flash'] ||= FlashHash.new
+      end
   
-    # Access the contents of the flash. Use <tt>flash["notice"]</tt> to read a notice you put there or 
-    # <tt>flash["notice"] = "hello"</tt> to put a new one.
-    def flash #:doc:
-      @session['flash'] ||= FlashHash.new
-    end
-  
-    # deprecated. use <tt>flash.keep</tt> instead
-    def keep_flash #:doc:
-      flash.keep
-    end
-  
+      # deprecated. use <tt>flash.keep</tt> instead
+      def keep_flash #:doc:
+        flash.keep
+      end
   
-    private
   
-    # marks flash entries as used and expose the flash to the view 
-    def fire_flash
-      flash.discard
-      @assigns["flash"] = flash
-    end
+      private
   
-    # deletes the flash entries that were not marked for keeping
-    def sweep_flash
-      flash.sweep
-    end
+      # marks flash entries as used and expose the flash to the view 
+      def fire_flash
+        flash.discard
+        @assigns["flash"] = flash
+      end
   
+      # deletes the flash entries that were not marked for keeping
+      def sweep_flash
+        flash.sweep
+      end  
   end
 end

actionpack/lib/action_controller/test_process.rb

-require File.dirname(__FILE__) + '/assertions/action_pack_assertions'
-require File.dirname(__FILE__) + '/assertions/active_record_assertions'
+require File.dirname(__FILE__) + '/assertions'
+require File.dirname(__FILE__) + '/deprecated_assertions'
 
 if defined?(RAILS_ROOT)
   # Temporary hack for getting functional tests in Rails running under 1.8.2
@@ -94,17 +94,6 @@ def initialize_default_values
   end
   
   class TestResponse < AbstractResponse #:nodoc:
-    # the class attribute ties a TestResponse to the assertions 
-    class << self
-      attr_accessor :assertion_target
-    end
-
-    # initializer
-    def initialize
-      TestResponse.assertion_target=self# if TestResponse.assertion_target.nil?
-      super()
-    end
-    
     # the response code of the request
     def response_code
       headers['Status'][0,3].to_i rescue 0
@@ -126,10 +115,12 @@ def redirect?
     end
     
     # was there a server-side error?
-    def server_error?
+    def error?
       (500..599).include?(response_code)
     end
 
+    alias_method :server_error?, :error?
+
     # returns the redirection location or nil
     def redirect_url
       redirect? ? headers['location'] : nil
@@ -281,8 +272,28 @@ def follow_redirect
           get(@response.redirected_to.delete(:action), @response.redirected_to.stringify_keys)
         end
 
-        def assigns(name)
-          @response.template.assigns[name.to_s]
+        def assigns(key = nil)
+          if key.nil?
+            @response.template.assigns
+          else
+            @response.template.assigns[key.to_s]
+          end
+        end
+        
+        def session
+          @response.session
+        end
+
+        def flash
+          @response.flash
+        end
+
+        def cookies
+          @response.cookies
+        end
+
+        def redirect_to_url
+          @response.redirect_url
         end
 
         def build_request_uri(action, parameters)

actionpack/lib/action_view/base.rb

@@ -119,7 +119,7 @@ class ActionViewError < StandardError #:nodoc:
   class Base
     include ERB::Util
     
-    attr_reader :first_render
+    attr_reader   :first_render
     attr_accessor :base_path, :assigns, :template_extension
     attr_accessor :controller
 
@@ -157,7 +157,7 @@ def self.register_template_handler(extension, klass)
     end
 
     def initialize(base_path = nil, assigns_for_first_render = {}, controller = nil)#:nodoc:
-      @base_path, @assigns = base_path, assigns_for_first_render
+      @base_path, @assigns = base_path, assigns_for_first_render.with_indifferent_access
       @controller = controller
     end
 

actionpack/test/controller/action_pack_assertions_test.rb

@@ -170,7 +170,6 @@ def test_flash_assertions_full
     process :flash_me
     assert @response.has_flash_with_contents?
     assert_flash_exists
-    assert ActionController::TestResponse.assertion_target.has_flash_with_contents?
     assert_flash_not_empty
     assert_flash_has 'hello'
     assert_flash_has_no 'stds'
@@ -385,4 +384,4 @@ def test_rendering_xml_respects_content_type
 	  process :hello_xml_world
 	  assert_equal('application/pdf', @controller.headers['Content-Type'])
   end
-end
+end
\ No newline at end of file