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

2 files changed, 0 insertions, 334 deletions

diff --git a/actionpack/lib/action_controller/assertions/action_pack_assertions.rb b/actionpack/lib/action_controller/assertions/action_pack_assertions.rb
deleted file mode 100644
index 9bbcc5b83f..0000000000
--- a/actionpack/lib/action_controller/assertions/action_pack_assertions.rb
+++ /dev/null
@@ -1,269 +0,0 @@
-require 'test/unit'
-require 'test/unit/assertions'
-require 'rexml/document'
-
-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
-      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
-      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
-      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) }
-      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) }
-      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] }
-      end
-
-      # -- cookie assertions ---------------------------------------------------
-
-      def assert_no_cookie(key = nil, message = nil)
-        response = acquire_assertion_target
-        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 = 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) }
-      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) }
-      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? }
-      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? }
-      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? }
-      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? }
-      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] }
-      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 }
-      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 }
-      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) }
-      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) }
-      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] }
-      end
-
-      # 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.elements.each(expression) { |e| matches << e.text }
-        if matches.empty? then
-          msg = build_message(message, "<?> not found in document", expression)
-          flunk(msg)
-          return
-        elsif matches.length < 2 then
-          matches = matches.first
-        end
-
-        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
-      end
-      
-    end # Assertions
-  end # Unit
-end # Test
diff --git a/actionpack/lib/action_controller/assertions/active_record_assertions.rb b/actionpack/lib/action_controller/assertions/active_record_assertions.rb
deleted file mode 100644
index cdc9b6951d..0000000000
--- a/actionpack/lib/action_controller/assertions/active_record_assertions.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-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