Module: Test::Unit::Assertions

Defined in:
lib/action_controller/assertions/action_pack_assertions.rb,
lib/action_controller/assertions/active_record_assertions.rb

Overview

:nodoc:

Instance Method Summary collapse

Instance Method Details

#acquire_assertion_target ⇒ Object

get the TestResponse object that these assertions depend upon



191
192
193
194
195
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 191

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

#assert_assigned_equal(expected = nil, key = nil, message = nil) ⇒ Object

ensures that the object assigned to the template on key is equal to expected object.



170
171
172
173
174
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 170

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

#assert_flash_empty(message = nil) ⇒ Object

ensure the flash is empty but existant



95
96
97
98
99
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 95

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

#assert_flash_equal(expected = nil, key = nil, message = nil) ⇒ Object 



108
109
110
111
112
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 108

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

#assert_flash_exists(message = nil) ⇒ Object

ensure the flash exists



81
82
83
84
85
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 81

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

#assert_flash_has(key = nil, message = nil) ⇒ Object

ensure that the flash has an object with the specified name



67
68
69
70
71
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 67

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

#assert_flash_has_no(key = nil, message = nil) ⇒ Object

ensure that the flash has no object with the specified name



74
75
76
77
78
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 74

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

#assert_flash_not_empty(message = nil) ⇒ Object

ensure the flash is not empty



102
103
104
105
106
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 102

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

#assert_flash_not_exists(message = nil) ⇒ Object

ensure the flash does not exist



88
89
90
91
92
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 88

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

#assert_invalid_column_on_record(key = nil, columns = "", message = nil) ⇒ Object

Assert the template object with the given name is an Active Record descendant and the specified column(s) are invalid.



34
35
36
37
38
39
40
41
42
 
# File 'lib/action_controller/assertions/active_record_assertions.rb', line 34

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

#assert_invalid_record(key = nil, message = nil) ⇒ Object

Assert the template object with the given name is an Active Record descendant and is invalid.



16
17
18
19
20
 
# File 'lib/action_controller/assertions/active_record_assertions.rb', line 16

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_redirect(message = nil) ⇒ Object

ensure we have be redirected



117
118
119
120
121
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 117

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

#assert_redirect_url(url = nil, message = nil) ⇒ Object

ensure our redirection url is an exact match



138
139
140
141
142
143
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 138

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

#assert_redirect_url_match(pattern = nil, message = nil) ⇒ Object

ensure our redirection url matches a pattern



146
147
148
149
150
151
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 146

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

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



123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 123

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

#assert_rendered_file(expected = nil, message = nil) ⇒ Object

ensure the request was rendered with the appropriate template file



29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 29

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

#assert_session_equal(expected = nil, key = nil, message = nil) ⇒ Object 



58
59
60
61
62
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 58

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

#assert_session_has(key = nil, message = nil) ⇒ Object

ensure that the session has an object with the specified name



45
46
47
48
49
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 45

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

#assert_session_has_no(key = nil, message = nil) ⇒ Object

ensure that the session has no object with the specified name



52
53
54
55
56
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 52

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

#assert_success(message = nil) ⇒ Object

ensure that the web request has been serviced correctly



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 12

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

#assert_template_has(key = nil, message = nil) ⇒ Object

ensure that a template object with the given name exists



156
157
158
159
160
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 156

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

#assert_template_has_no(key = nil, message = nil) ⇒ Object

ensure that a template object with the given name does not exist



163
164
165
166
167
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 163

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

#assert_template_xpath_match(expression = nil, expected = nil, message = nil) ⇒ Object

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.



178
179
180
181
182
183
184
185
186
 
# File 'lib/action_controller/assertions/action_pack_assertions.rb', line 178

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

#assert_valid_column_on_record(key = nil, columns = "", message = nil) ⇒ Object

Assert the template object with the given name is an Active Record descendant and the specified column(s) are valid.



23
24
25
26
27
28
29
30
31
 
# File 'lib/action_controller/assertions/active_record_assertions.rb', line 23

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_valid_record(key = nil, message = nil) ⇒ Object

Assert the template object with the given name is an Active Record descendant and is valid.



9
10
11
12
13
 
# File 'lib/action_controller/assertions/active_record_assertions.rb', line 9

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