diff options
| -rw-r--r-- | actionpack/lib/action_controller/assertions.rb | 321 | ||||
| -rw-r--r-- | actionpack/lib/action_controller/assertions/assert_dom.rb | 28 | ||||
| -rw-r--r-- | actionpack/lib/action_controller/assertions/assert_response.rb | 137 | ||||
| -rw-r--r-- | actionpack/lib/action_controller/assertions/assert_routing.rb | 85 | ||||
| -rw-r--r-- | actionpack/lib/action_controller/assertions/assert_select.rb (renamed from actionpack/lib/action_controller/assert_select.rb) | 6 | ||||
| -rw-r--r-- | actionpack/lib/action_controller/assertions/assert_tag.rb (renamed from actionpack/lib/action_controller/assert_tag.rb) | 6 | ||||
| -rw-r--r-- | actionpack/lib/action_controller/assertions/assert_valid.rb | 15 | ||||
| -rw-r--r-- | actionpack/lib/action_controller/test_process.rb | 10 | ||||
| -rw-r--r-- | actionpack/test/controller/assert_select_test.rb | 1 |
9 files changed, 336 insertions, 273 deletions
diff --git a/actionpack/lib/action_controller/assertions.rb b/actionpack/lib/action_controller/assertions.rb index db130ea3d1..c11cc004db 100644 --- a/actionpack/lib/action_controller/assertions.rb +++ b/actionpack/lib/action_controller/assertions.rb @@ -1,276 +1,75 @@ require 'test/unit' require 'test/unit/assertions' -require 'rexml/document' -require File.dirname(__FILE__) + "/vendor/html-scanner/html/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 are available for the view. - # * session: Objects being saved in the session. - # * flash: The flash objects 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 - # - # For historic reasons, the assigns hash uses string-based keys. So assigns[:person] won't work, but assigns["person"] will. To - # appease our yearning for symbols, though, an alternative accessor has been deviced using a method call instead of index referencing. - # So assigns(:person) will work just like assigns["person"], but again, assigns[:person] will not work. - # - # 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 followed, triggering another - # action call which can then be asserted against. - # - # == Manipulating the request collections - # - # The collections described above link to the response, so you can test if what the actions were expected to do happened. But - # sometimes you also want to manipulate these collections in the incoming request. This is really only relevant for sessions - # and cookies, though. For sessions, you just do: - # - # @request.session[:key] = "value" - # - # For cookies, you need to manually create the cookie, like this: - # - # @request.cookies["key"] = CGI::Cookie.new("key", "value") - # - # == Testing named routes - # - # If you're using named routes, they can be easily tested using the original named routes methods straight in the test case. - # Example: - # - # assert_redirected_to page_url(:title => 'foo') - 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) - 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 - 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?('/') - value['controller'] = ActionController::Routing.controller_relative_to(value['controller'], @controller.class.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 - - # 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, extras) - 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 +module ActionController #: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 are available for the view. + # * session: Objects being saved in the session. + # * flash: The flash objects 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 + # + # For historic reasons, the assigns hash uses string-based keys. So assigns[:person] won't work, but assigns["person"] will. To + # appease our yearning for symbols, though, an alternative accessor has been deviced using a method call instead of index referencing. + # So assigns(:person) will work just like assigns["person"], but again, assigns[:person] will not work. + # + # 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 followed, triggering another + # action call which can then be asserted against. + # + # == Manipulating the request collections + # + # The collections described above link to the response, so you can test if what the actions were expected to do happened. But + # sometimes you also want to manipulate these collections in the incoming request. This is really only relevant for sessions + # and cookies, though. For sessions, you just do: + # + # @request.session[:key] = "value" + # + # For cookies, you need to manually create the cookie, like this: + # + # @request.cookies["key"] = CGI::Cookie.new("key", "value") + # + # == Testing named routes + # + # If you're using named routes, they can be easily tested using the original named routes methods straight in the test case. + # Example: + # + # assert_redirected_to page_url(:title => 'foo') + module Assertions + 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 +require File.dirname(__FILE__) + '/assertions/assert_response' +require File.dirname(__FILE__) + '/assertions/assert_select' +require File.dirname(__FILE__) + '/assertions/assert_tag' +require File.dirname(__FILE__) + '/assertions/assert_dom' +require File.dirname(__FILE__) + '/assertions/assert_routing' +require File.dirname(__FILE__) + '/assertions/assert_valid' - # 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 +module Test #:nodoc: + module Unit #:nodoc: + class TestCase #:nodoc: + include ActionController::Assertions::ResponseAssertions + include ActionController::Assertions::SelectorAssertions + include ActionController::Assertions::RoutingAssertions + include ActionController::Assertions::TagAssertions + include ActionController::Assertions::DomAssertions + include ActionController::Assertions::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 - def clean_backtrace(&block) yield rescue AssertionFailedError => e path = File.expand_path(__FILE__) raise AssertionFailedError, e.message, e.backtrace.reject { |line| File.expand_path(line) =~ /#{path}/ } 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
\ No newline at end of file diff --git a/actionpack/lib/action_controller/assertions/assert_dom.rb b/actionpack/lib/action_controller/assertions/assert_dom.rb new file mode 100644 index 0000000000..a765dff2cc --- /dev/null +++ b/actionpack/lib/action_controller/assertions/assert_dom.rb @@ -0,0 +1,28 @@ +require 'test/unit' +require 'test/unit/assertions' + +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
\ No newline at end of file diff --git a/actionpack/lib/action_controller/assertions/assert_response.rb b/actionpack/lib/action_controller/assertions/assert_response.rb new file mode 100644 index 0000000000..5d5effc493 --- /dev/null +++ b/actionpack/lib/action_controller/assertions/assert_response.rb @@ -0,0 +1,137 @@ +require 'test/unit' +require 'test/unit/assertions' +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 code number as the type, like assert_response(501) + 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 + 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?('/') + value['controller'] = ActionController::Routing.controller_relative_to(value['controller'], @controller.class.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
\ No newline at end of file diff --git a/actionpack/lib/action_controller/assertions/assert_routing.rb b/actionpack/lib/action_controller/assertions/assert_routing.rb new file mode 100644 index 0000000000..a94bb719f2 --- /dev/null +++ b/actionpack/lib/action_controller/assertions/assert_routing.rb @@ -0,0 +1,85 @@ +require 'test/unit' +require 'test/unit/assertions' + +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, extras) + 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
\ No newline at end of file diff --git a/actionpack/lib/action_controller/assert_select.rb b/actionpack/lib/action_controller/assertions/assert_select.rb index 01bb3ca28d..7e22d6b655 100644 --- a/actionpack/lib/action_controller/assert_select.rb +++ b/actionpack/lib/action_controller/assertions/assert_select.rb @@ -6,7 +6,7 @@ require 'test/unit' require 'test/unit/assertions' require 'rexml/document' -require File.dirname(__FILE__) + "/vendor/html-scanner/html/document" +require File.dirname(__FILE__) + "/../vendor/html-scanner/html/document" module ActionController @@ -552,6 +552,4 @@ EOT end end end -end - -Test::Unit::TestCase.send :include, ActionController::Assertions::SelectorAssertions
\ No newline at end of file +end
\ No newline at end of file diff --git a/actionpack/lib/action_controller/assert_tag.rb b/actionpack/lib/action_controller/assertions/assert_tag.rb index 64d39b0010..dc80b442b7 100644 --- a/actionpack/lib/action_controller/assert_tag.rb +++ b/actionpack/lib/action_controller/assertions/assert_tag.rb @@ -1,7 +1,7 @@ require 'test/unit' require 'test/unit/assertions' require 'rexml/document' -require File.dirname(__FILE__) + "/vendor/html-scanner/html/document" +require File.dirname(__FILE__) + "/../vendor/html-scanner/html/document" module ActionController module Assertions @@ -116,6 +116,4 @@ module ActionController end end end -end - -Test::Unit::TestCase.send :include, ActionController::Assertions::TagAssertions
\ No newline at end of file +end
\ No newline at end of file diff --git a/actionpack/lib/action_controller/assertions/assert_valid.rb b/actionpack/lib/action_controller/assertions/assert_valid.rb new file mode 100644 index 0000000000..b807a8902f --- /dev/null +++ b/actionpack/lib/action_controller/assertions/assert_valid.rb @@ -0,0 +1,15 @@ +require 'test/unit' +require 'test/unit/assertions' + +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
\ No newline at end of file diff --git a/actionpack/lib/action_controller/test_process.rb b/actionpack/lib/action_controller/test_process.rb index 511c759e97..f6c7776b44 100644 --- a/actionpack/lib/action_controller/test_process.rb +++ b/actionpack/lib/action_controller/test_process.rb @@ -1,7 +1,9 @@ -require File.dirname(__FILE__) + '/assertions' -require File.dirname(__FILE__) + '/assert_select' -require File.dirname(__FILE__) + '/assert_tag' -require File.dirname(__FILE__) + '/deprecated_assertions' +begin + require File.dirname(__FILE__) + '/assertions' + require File.dirname(__FILE__) + '/deprecated_assertions' +rescue Exception => e + print e +end module ActionController #:nodoc: class Base diff --git a/actionpack/test/controller/assert_select_test.rb b/actionpack/test/controller/assert_select_test.rb index 2117c852c0..cd1ba129a5 100644 --- a/actionpack/test/controller/assert_select_test.rb +++ b/actionpack/test/controller/assert_select_test.rb @@ -7,6 +7,7 @@ require File.dirname(__FILE__) + '/../abstract_unit' require File.dirname(__FILE__) + '/fake_controllers' require "action_mailer" + class AssertSelectTest < Test::Unit::TestCase class AssertSelectController < ActionController::Base def response_with=(content) |