diff options
author | David Heinemeier Hansson <david@loudthinking.com> | 2004-11-24 01:04:44 +0000 |
---|---|---|
committer | David Heinemeier Hansson <david@loudthinking.com> | 2004-11-24 01:04:44 +0000 |
commit | db045dbbf60b53dbe013ef25554fd013baf88134 (patch) | |
tree | 257830e3c76458c8ff3d1329de83f32b23926028 /actionpack/lib/action_controller/assertions | |
download | rails-db045dbbf60b53dbe013ef25554fd013baf88134.tar.gz rails-db045dbbf60b53dbe013ef25554fd013baf88134.tar.bz2 rails-db045dbbf60b53dbe013ef25554fd013baf88134.zip |
Initial
git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@4 5ecf4fe2-1ee6-0310-87b1-e25e094e27de
Diffstat (limited to 'actionpack/lib/action_controller/assertions')
-rw-r--r-- | actionpack/lib/action_controller/assertions/action_pack_assertions.rb | 199 | ||||
-rw-r--r-- | actionpack/lib/action_controller/assertions/active_record_assertions.rb | 65 |
2 files changed, 264 insertions, 0 deletions
diff --git a/actionpack/lib/action_controller/assertions/action_pack_assertions.rb b/actionpack/lib/action_controller/assertions/action_pack_assertions.rb new file mode 100644 index 0000000000..2cfbcbc938 --- /dev/null +++ b/actionpack/lib/action_controller/assertions/action_pack_assertions.rb @@ -0,0 +1,199 @@ +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 + + # -- 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 existant + 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] } + 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 + + # -- 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 } + matches = matches.first if matches.length < 2 + + 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 new file mode 100644 index 0000000000..9167eae53e --- /dev/null +++ b/actionpack/lib/action_controller/assertions/active_record_assertions.rb @@ -0,0 +1,65 @@ +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.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.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 |