module ActionDispatch module Assertions # A small suite of assertions that test responses from \Rails applications. module ResponseAssertions # Asserts that the response is one of the following types: # # * :success - Status code was in the 200-299 range # * :redirect - Status code was in the 300-399 range # * :missing - Status code was 404 # * :error - 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 Rack::Utils::SYMBOL_TO_STATUS_CODE for a full list. # # # assert that the response was a redirection # assert_response :redirect # # # assert that the response code was status code 401 (unauthorized) # assert_response 401 def assert_response(type, message = nil) message ||= "Expected response to be a <#{type}>, but was <#{@response.response_code}>" if Symbol === type if [:success, :missing, :redirect, :error].include?(type) assert @response.send("#{type}?"), message else code = Rack::Utils::SYMBOL_TO_STATUS_CODE[type] if code.nil? raise ArgumentError, "Invalid response type :#{type}" end assert_equal code, @response.response_code, message end else assert_equal type, @response.response_code, message 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. # # # assert that the redirection was to the "index" action on the WeblogController # assert_redirected_to controller: "weblog", action: "index" # # # assert that the redirection was to the named route login_url # assert_redirected_to login_url # # # assert that the redirection was to the url for @customer # assert_redirected_to @customer # # # asserts that the redirection matches the regular expression # assert_redirected_to %r(\Ahttp://example.org) def assert_redirected_to(options = {}, message=nil) assert_response(:redirect, message) return true if options === @response.location redirect_is = normalize_argument_to_redirection(@response.location) redirect_expected = normalize_argument_to_redirection(options) message ||= "Expected response to be a redirect to <#{redirect_expected}> but was a redirect to <#{redirect_is}>" assert_operator redirect_expected, :===, redirect_is, message end private # Proxy to to_param if the object will respond to it. def parameterize(value) value.respond_to?(:to_param) ? value.to_param : value end def normalize_argument_to_redirection(fragment) if Regexp === fragment fragment else handle = @controller || Class.new(ActionController::Metal) do include ActionController::Redirecting def initialize(request) @_request = request end end.new(@request) handle._compute_redirect_to_location(fragment) end end end end end