1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
|
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
# -- cookie assertions ---------------------------------------------------
def assert_no_cookie(key = nil, message = nil)
response = acquire_assertion_target
actual = response.cookies[key]
msg = build_message(message, "<?> not expected in cookies['?']", actual, key)
assert_block(msg) { actual.nil? or actual.empty? }
end
def assert_cookie_equal(expected = nil, key = nil, message = nil)
response = acquire_assertion_target
actual = response.cookies[key]
actual = actual.first if actual
msg = build_message(message, "<?> expected in cookies['?'] but was <?>", expected, key, actual)
assert_block(msg) { expected == actual }
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 existent
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].respond_to?(:to_param) ? response.redirected_to[k].to_param : response.redirected_to[k] if 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
# -- routing assertions --------------------------------------------------
# Asserts that the routing of the given path is handled correctly and that the parsed options match.
def assert_recognizes(expected_options, path, extras={}, message=nil)
# Load routes.rb if it hasn't been loaded.
ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
# Assume given controller
request = ActionController::TestRequest.new({}, {}, nil)
request.path = path
ActionController::Routing::Routes.recognize!(request)
expected_options = expected_options.clone
extras.each_key { |key| expected_options.delete key } unless extras.nil?
msg = build_message(message, "The recognized options <?> did not match <?>",
request.path_parameters, expected_options)
assert_block(msg) { request.path_parameters == expected_options }
end
# Asserts that the provided options can be used to generate the provided path.
def assert_generates(expected_path, options, defaults={}, extras = {}, message=nil)
# Load routes.rb if it hasn't been loaded.
ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
# Assume given controller
request = ActionController::TestRequest.new({}, {}, nil)
request.path_parameters = (defaults or {}).clone
request.path_parameters[:controller] ||= options[:controller]
generated_path, found_extras = ActionController::Routing::Routes.generate(options, request)
generated_path = generated_path.join('/')
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
# asserts that path and options match both ways, in other words, the URL generated from
# options is same as path, and also that the options recognized from path are same as options
def assert_routing(path, options, defaults={}, extras={}, message=nil)
assert_recognizes(options, path, extras, message)
assert_generates(path, options, defaults, extras, message)
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 }
if matches.empty? then
msg = build_message(message, "<?> not found in document", expression)
flunk(msg)
return
elsif matches.length < 2 then
matches = matches.first
end
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
|