Module: ActionController::Assertions::ResponseAssertions

Defined in:
lib/action_controller/assertions/response_assertions.rb

Overview

A small suite of assertions that test responses from Rails applications.

Instance Method Summary collapse

Instance Method Details

#assert_redirected_to(options = {}, message = nil) ⇒ Object

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.

Examples

# 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 

# assert that the redirection was to the url for @customer
assert_redirected_to @customer



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/action_controller/assertions/response_assertions.rb', line 59

def assert_redirected_to(options = {}, message=nil)
  clean_backtrace do
    assert_response(:redirect, message)
    return true if options == @response.redirected_to

    # Support partial arguments for hash redirections
    if options.is_a?(Hash) && @response.redirected_to.is_a?(Hash)
      if options.all? {|(key, value)| @response.redirected_to[key] == value}
        callstack = caller.dup
        callstack.slice!(0, 2)
        ::ActiveSupport::Deprecation.warn("Using assert_redirected_to with partial hash arguments is deprecated. Specify the full set arguments instead", callstack)
        return true
      end
    end

    redirected_to_after_normalisation = normalize_argument_to_redirection(@response.redirected_to)
    options_after_normalisation       = normalize_argument_to_redirection(options)

    if redirected_to_after_normalisation != options_after_normalisation
      flunk "Expected response to be a redirect to <#{options_after_normalisation}> but was a redirect to <#{redirected_to_after_normalisation}>"
    end
  end
end

#assert_response(type, message = nil) ⇒ Object

Asserts that the response is one of the following types:

  • :success - Status code was 200

  • :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 ActionController::StatusCodes for a full list.

Examples

# assert that the response was a redirection
assert_response :redirect

# assert that the response code was status code 401 (unauthorized)
assert_response 401



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/action_controller/assertions/response_assertions.rb', line 24

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
    elsif type.is_a?(Symbol) && @response.response_code == ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[type]
      assert_block("") { true } # to count the assertion
    else
      if @response.error?
        exception = @response.template.instance_variable_get(:@exception)
        exception_message = exception && exception.message
        assert_block(build_message(message, "Expected response to be a <?>, but was <?>\n<?>", type, @response.response_code, exception_message.to_s)) { false }
      else
        assert_block(build_message(message, "Expected response to be a <?>, but was <?>", type, @response.response_code)) { false }
      end
    end
  end
end

#assert_template(options = {}, message = nil) ⇒ Object

Asserts that the request was rendered with the appropriate template file or partials

Examples

# assert that the "new" view template was rendered
assert_template "new"

# assert that the "new" view template was rendered with Symbol
assert_template :new

# assert that the "_customer" partial was rendered twice
assert_template :partial => '_customer', :count => 2

# assert that no partials were rendered
assert_template :partial => false



99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/action_controller/assertions/response_assertions.rb', line 99

def assert_template(options = {}, message = nil)
  clean_backtrace do
    case options
     when NilClass, String, Symbol
      rendered = @response.rendered[:template].to_s
      msg = build_message(message,
              "expecting <?> but rendering with <?>",
              options, rendered)
      assert_block(msg) do
        if options.nil?
          @response.rendered[:template].blank?
        else
          rendered.to_s.match(options.to_s)
        end
      end
    when Hash
      if expected_partial = options[:partial]
        partials = @response.rendered[:partials]
        if expected_count = options[:count]
          found = partials.detect { |p, _| p.to_s.match(expected_partial) }
          actual_count = found.nil? ? 0 : found.second
          msg = build_message(message,
                  "expecting ? to be rendered ? time(s) but rendered ? time(s)",
                   expected_partial, expected_count, actual_count)
          assert(actual_count == expected_count.to_i, msg)
        else
          msg = build_message(message,
                  "expecting partial <?> but action rendered <?>",
                  options[:partial], partials.keys)
          assert(partials.keys.any? { |p| p.to_s.match(expected_partial) }, msg)
        end
      else
        assert @response.rendered[:partials].empty?,
          "Expected no partials to be rendered"
      end
    else
      raise ArgumentError  
    end
  end
end