Changesets can be listed by changeset number.
The Git repository is here.
- Revision:
- 373
- Log:
Initial import of Radiant 0.9.1, which is now packaged as a gem. This is an
import of the tagged 0.9.1 source checked out from GitHub, which isn't quite
the same as the gem distribution - but it doesn't seem to be available in an
archived form and the installed gem already has modifications, so this is
the closest I can get.
- Author:
- rool
- Date:
- Mon Mar 21 13:40:05 +0000 2011
- Size:
- 15566 Bytes
1 | require 'abstract_unit' |
2 | |
3 | # a controller class to facilitate the tests |
4 | class ActionPackAssertionsController < ActionController::Base |
5 | |
6 | # this does absolutely nothing |
7 | def nothing() head :ok end |
8 | |
9 | # a standard template |
10 | def hello_world() render :template => "test/hello_world"; end |
11 | |
12 | # a standard template |
13 | def hello_xml_world() render :template => "test/hello_xml_world"; end |
14 | |
15 | # a standard partial |
16 | def partial() render :partial => 'test/partial'; end |
17 | |
18 | # a redirect to an internal location |
19 | def redirect_internal() redirect_to "/nothing"; end |
20 | |
21 | def redirect_to_action() redirect_to :action => "flash_me", :id => 1, :params => { "panda" => "fun" }; end |
22 | |
23 | def redirect_to_controller() redirect_to :controller => "elsewhere", :action => "flash_me"; end |
24 | |
25 | def redirect_to_controller_with_symbol() redirect_to :controller => :elsewhere, :action => :flash_me; end |
26 | |
27 | def redirect_to_path() redirect_to '/some/path' end |
28 | |
29 | def redirect_to_named_route() redirect_to route_one_url end |
30 | |
31 | # a redirect to an external location |
32 | def redirect_external() redirect_to "http://www.rubyonrails.org"; end |
33 | |
34 | # a 404 |
35 | def response404() head '404 AWOL' end |
36 | |
37 | # a 500 |
38 | def response500() head '500 Sorry' end |
39 | |
40 | # a fictional 599 |
41 | def response599() head '599 Whoah!' end |
42 | |
43 | # putting stuff in the flash |
44 | def flash_me |
45 | flash['hello'] = 'my name is inigo montoya...' |
46 | render :text => "Inconceivable!" |
47 | end |
48 | |
49 | # we have a flash, but nothing is in it |
50 | def flash_me_naked |
51 | flash.clear |
52 | render :text => "wow!" |
53 | end |
54 | |
55 | # assign some template instance variables |
56 | def assign_this |
57 | @howdy = "ho" |
58 | render :inline => "Mr. Henke" |
59 | end |
60 | |
61 | def render_based_on_parameters |
62 | render :text => "Mr. #{params[:name]}" |
63 | end |
64 | |
65 | def render_url |
66 | render :text => "<div>#{url_for(:action => 'flash_me', :only_path => true)}</div>" |
67 | end |
68 | |
69 | def render_text_with_custom_content_type |
70 | render :text => "Hello!", :content_type => Mime::RSS |
71 | end |
72 | |
73 | # puts something in the session |
74 | def session_stuffing |
75 | session['xmas'] = 'turkey' |
76 | render :text => "ho ho ho" |
77 | end |
78 | |
79 | # raises exception on get requests |
80 | def raise_on_get |
81 | raise "get" if request.get? |
82 | render :text => "request method: #{request.env['REQUEST_METHOD']}" |
83 | end |
84 | |
85 | # raises exception on post requests |
86 | def raise_on_post |
87 | raise "post" if request.post? |
88 | render :text => "request method: #{request.env['REQUEST_METHOD']}" |
89 | end |
90 | |
91 | def get_valid_record |
92 | @record = Class.new do |
93 | def valid? |
94 | true |
95 | end |
96 | |
97 | def errors |
98 | Class.new do |
99 | def full_messages; []; end |
100 | end.new |
101 | end |
102 | |
103 | end.new |
104 | |
105 | render :nothing => true |
106 | end |
107 | |
108 | |
109 | def get_invalid_record |
110 | @record = Class.new do |
111 | |
112 | def valid? |
113 | false |
114 | end |
115 | |
116 | def errors |
117 | Class.new do |
118 | def full_messages; ['...stuff...']; end |
119 | end.new |
120 | end |
121 | end.new |
122 | |
123 | render :nothing => true |
124 | end |
125 | |
126 | # 911 |
127 | def rescue_action(e) raise; end |
128 | end |
129 | |
130 | # Used to test that assert_response includes the exception message |
131 | # in the failure message when an action raises and assert_response |
132 | # is expecting something other than an error. |
133 | class AssertResponseWithUnexpectedErrorController < ActionController::Base |
134 | def index |
135 | raise 'FAIL' |
136 | end |
137 | |
138 | def show |
139 | render :text => "Boom", :status => 500 |
140 | end |
141 | end |
142 | |
143 | class UserController < ActionController::Base |
144 | end |
145 | |
146 | module Admin |
147 | class InnerModuleController < ActionController::Base |
148 | def index |
149 | render :nothing => true |
150 | end |
151 | |
152 | def redirect_to_index |
153 | redirect_to admin_inner_module_path |
154 | end |
155 | |
156 | def redirect_to_absolute_controller |
157 | redirect_to :controller => '/content' |
158 | end |
159 | |
160 | def redirect_to_fellow_controller |
161 | redirect_to :controller => 'user' |
162 | end |
163 | |
164 | def redirect_to_top_level_named_route |
165 | redirect_to top_level_url(:id => "foo") |
166 | end |
167 | end |
168 | end |
169 | |
170 | # a test case to exercise the new capabilities TestRequest & TestResponse |
171 | class ActionPackAssertionsControllerTest < ActionController::TestCase |
172 | # let's get this party started |
173 | def setup |
174 | ActionController::Routing::Routes.reload |
175 | ActionController::Routing.use_controllers!(%w(action_pack_assertions admin/inner_module user content admin/user)) |
176 | end |
177 | |
178 | def teardown |
179 | ActionController::Routing::Routes.reload |
180 | end |
181 | |
182 | # -- assertion-based testing ------------------------------------------------ |
183 | |
184 | def test_assert_tag_and_url_for |
185 | get :render_url |
186 | assert_tag :content => "/action_pack_assertions/flash_me" |
187 | end |
188 | |
189 | # test the get method, make sure the request really was a get |
190 | def test_get |
191 | assert_raise(RuntimeError) { get :raise_on_get } |
192 | get :raise_on_post |
193 | assert_equal @response.body, 'request method: GET' |
194 | end |
195 | |
196 | # test the get method, make sure the request really was a get |
197 | def test_post |
198 | assert_raise(RuntimeError) { post :raise_on_post } |
199 | post :raise_on_get |
200 | assert_equal @response.body, 'request method: POST' |
201 | end |
202 | |
203 | # the following test fails because the request_method is now cached on the request instance |
204 | # test the get/post switch within one test action |
205 | # def test_get_post_switch |
206 | # post :raise_on_get |
207 | # assert_equal @response.body, 'request method: POST' |
208 | # get :raise_on_post |
209 | # assert_equal @response.body, 'request method: GET' |
210 | # post :raise_on_get |
211 | # assert_equal @response.body, 'request method: POST' |
212 | # get :raise_on_post |
213 | # assert_equal @response.body, 'request method: GET' |
214 | # end |
215 | |
216 | # test the redirection to a named route |
217 | def test_assert_redirect_to_named_route |
218 | with_routing do |set| |
219 | set.draw do |map| |
220 | map.route_one 'route_one', :controller => 'action_pack_assertions', :action => 'nothing' |
221 | map.connect ':controller/:action/:id' |
222 | end |
223 | set.install_helpers |
224 | |
225 | process :redirect_to_named_route |
226 | assert_redirected_to 'http://test.host/route_one' |
227 | assert_redirected_to route_one_url |
228 | end |
229 | end |
230 | |
231 | def test_assert_redirect_to_named_route_failure |
232 | with_routing do |set| |
233 | set.draw do |map| |
234 | map.route_one 'route_one', :controller => 'action_pack_assertions', :action => 'nothing', :id => 'one' |
235 | map.route_two 'route_two', :controller => 'action_pack_assertions', :action => 'nothing', :id => 'two' |
236 | map.connect ':controller/:action/:id' |
237 | end |
238 | process :redirect_to_named_route |
239 | assert_raise(ActiveSupport::TestCase::Assertion) do |
240 | assert_redirected_to 'http://test.host/route_two' |
241 | end |
242 | assert_raise(ActiveSupport::TestCase::Assertion) do |
243 | assert_redirected_to :controller => 'action_pack_assertions', :action => 'nothing', :id => 'two' |
244 | end |
245 | assert_raise(ActiveSupport::TestCase::Assertion) do |
246 | assert_redirected_to route_two_url |
247 | end |
248 | end |
249 | end |
250 | |
251 | def test_assert_redirect_to_nested_named_route |
252 | with_routing do |set| |
253 | set.draw do |map| |
254 | map.admin_inner_module 'admin/inner_module', :controller => 'admin/inner_module', :action => 'index' |
255 | map.connect ':controller/:action/:id' |
256 | end |
257 | @controller = Admin::InnerModuleController.new |
258 | process :redirect_to_index |
259 | # redirection is <{"action"=>"index", "controller"=>"admin/admin/inner_module"}> |
260 | assert_redirected_to admin_inner_module_path |
261 | end |
262 | end |
263 | |
264 | def test_assert_redirected_to_top_level_named_route_from_nested_controller |
265 | with_routing do |set| |
266 | set.draw do |map| |
267 | map.top_level '/action_pack_assertions/:id', :controller => 'action_pack_assertions', :action => 'index' |
268 | map.connect ':controller/:action/:id' |
269 | end |
270 | @controller = Admin::InnerModuleController.new |
271 | process :redirect_to_top_level_named_route |
272 | # assert_redirected_to "http://test.host/action_pack_assertions/foo" would pass because of exact match early return |
273 | assert_redirected_to "/action_pack_assertions/foo" |
274 | end |
275 | end |
276 | |
277 | def test_assert_redirected_to_top_level_named_route_with_same_controller_name_in_both_namespaces |
278 | with_routing do |set| |
279 | set.draw do |map| |
280 | # this controller exists in the admin namespace as well which is the only difference from previous test |
281 | map.top_level '/user/:id', :controller => 'user', :action => 'index' |
282 | map.connect ':controller/:action/:id' |
283 | end |
284 | @controller = Admin::InnerModuleController.new |
285 | process :redirect_to_top_level_named_route |
286 | # assert_redirected_to top_level_url('foo') would pass because of exact match early return |
287 | assert_redirected_to top_level_path('foo') |
288 | end |
289 | end |
290 | |
291 | # -- standard request/response object testing -------------------------------- |
292 | |
293 | # make sure that the template objects exist |
294 | def test_template_objects_alive |
295 | process :assign_this |
296 | assert !@response.has_template_object?('hi') |
297 | assert @response.has_template_object?('howdy') |
298 | end |
299 | |
300 | # make sure we don't have template objects when we shouldn't |
301 | def test_template_object_missing |
302 | process :nothing |
303 | assert_nil @response.template_objects['howdy'] |
304 | end |
305 | |
306 | # check the empty flashing |
307 | def test_flash_me_naked |
308 | process :flash_me_naked |
309 | assert !@response.has_flash? |
310 | assert !@response.has_flash_with_contents? |
311 | end |
312 | |
313 | # check if we have flash objects |
314 | def test_flash_haves |
315 | process :flash_me |
316 | assert @response.has_flash? |
317 | assert @response.has_flash_with_contents? |
318 | assert @response.has_flash_object?('hello') |
319 | end |
320 | |
321 | # ensure we don't have flash objects |
322 | def test_flash_have_nots |
323 | process :nothing |
324 | assert !@response.has_flash? |
325 | assert !@response.has_flash_with_contents? |
326 | assert_nil @response.flash['hello'] |
327 | end |
328 | |
329 | # check if we were rendered by a file-based template? |
330 | def test_rendered_action |
331 | process :nothing |
332 | assert_nil @response.rendered[:template] |
333 | |
334 | process :hello_world |
335 | assert @response.rendered[:template] |
336 | assert 'hello_world', @response.rendered[:template].to_s |
337 | end |
338 | |
339 | def test_assert_template_with_partial |
340 | get :partial |
341 | assert_template :partial => '_partial' |
342 | end |
343 | |
344 | def test_assert_template_with_nil |
345 | get :nothing |
346 | assert_template nil |
347 | end |
348 | |
349 | def test_assert_template_with_string |
350 | get :hello_world |
351 | assert_template 'hello_world' |
352 | end |
353 | |
354 | def test_assert_template_with_symbol |
355 | get :hello_world |
356 | assert_template :hello_world |
357 | end |
358 | |
359 | def test_assert_template_with_bad_argument |
360 | assert_raise(ArgumentError) { assert_template 1 } |
361 | end |
362 | |
363 | # check the redirection location |
364 | def test_redirection_location |
365 | process :redirect_internal |
366 | assert_equal 'http://test.host/nothing', @response.redirect_url |
367 | |
368 | process :redirect_external |
369 | assert_equal 'http://www.rubyonrails.org', @response.redirect_url |
370 | end |
371 | |
372 | def test_no_redirect_url |
373 | process :nothing |
374 | assert_nil @response.redirect_url |
375 | end |
376 | |
377 | |
378 | # check server errors |
379 | def test_server_error_response_code |
380 | process :response500 |
381 | assert @response.server_error? |
382 | |
383 | process :response599 |
384 | assert @response.server_error? |
385 | |
386 | process :response404 |
387 | assert !@response.server_error? |
388 | end |
389 | |
390 | # check a 404 response code |
391 | def test_missing_response_code |
392 | process :response404 |
393 | assert @response.missing? |
394 | end |
395 | |
396 | # check client errors |
397 | def test_client_error_response_code |
398 | process :response404 |
399 | assert @response.client_error? |
400 | end |
401 | |
402 | # check to see if our redirection matches a pattern |
403 | def test_redirect_url_match |
404 | process :redirect_external |
405 | assert @response.redirect? |
406 | assert @response.redirect_url_match?("rubyonrails") |
407 | assert @response.redirect_url_match?(/rubyonrails/) |
408 | assert !@response.redirect_url_match?("phpoffrails") |
409 | assert !@response.redirect_url_match?(/perloffrails/) |
410 | end |
411 | |
412 | # check for a redirection |
413 | def test_redirection |
414 | process :redirect_internal |
415 | assert @response.redirect? |
416 | |
417 | process :redirect_external |
418 | assert @response.redirect? |
419 | |
420 | process :nothing |
421 | assert !@response.redirect? |
422 | end |
423 | |
424 | # check a successful response code |
425 | def test_successful_response_code |
426 | process :nothing |
427 | assert @response.success? |
428 | end |
429 | |
430 | # a basic check to make sure we have a TestResponse object |
431 | def test_has_response |
432 | process :nothing |
433 | assert_kind_of ActionController::TestResponse, @response |
434 | end |
435 | |
436 | def test_render_based_on_parameters |
437 | process :render_based_on_parameters, "name" => "David" |
438 | assert_equal "Mr. David", @response.body |
439 | end |
440 | |
441 | |
442 | def test_assert_redirection_fails_with_incorrect_controller |
443 | process :redirect_to_controller |
444 | assert_raise(ActiveSupport::TestCase::Assertion) do |
445 | assert_redirected_to :controller => "action_pack_assertions", :action => "flash_me" |
446 | end |
447 | end |
448 | |
449 | def test_assert_redirection_with_extra_controller_option |
450 | get :redirect_to_action |
451 | assert_redirected_to :controller => 'action_pack_assertions', :action => "flash_me", :id => 1, :params => { :panda => 'fun' } |
452 | end |
453 | |
454 | def test_redirected_to_url_leading_slash |
455 | process :redirect_to_path |
456 | assert_redirected_to '/some/path' |
457 | end |
458 | |
459 | def test_redirected_to_url_no_leadling_slash |
460 | process :redirect_to_path |
461 | assert_deprecated /leading/ do |
462 | assert_redirected_to 'some/path' |
463 | end |
464 | end |
465 | |
466 | def test_redirected_to_url_full_url |
467 | process :redirect_to_path |
468 | assert_redirected_to 'http://test.host/some/path' |
469 | end |
470 | |
471 | def test_assert_redirection_with_symbol |
472 | process :redirect_to_controller_with_symbol |
473 | assert_nothing_raised { |
474 | assert_redirected_to :controller => "elsewhere", :action => "flash_me" |
475 | } |
476 | process :redirect_to_controller_with_symbol |
477 | assert_nothing_raised { |
478 | assert_redirected_to :controller => :elsewhere, :action => :flash_me |
479 | } |
480 | end |
481 | |
482 | def test_redirected_to_with_nested_controller |
483 | @controller = Admin::InnerModuleController.new |
484 | get :redirect_to_absolute_controller |
485 | assert_redirected_to :controller => '/content' |
486 | |
487 | get :redirect_to_fellow_controller |
488 | assert_redirected_to :controller => 'admin/user' |
489 | end |
490 | |
491 | def test_assert_valid |
492 | get :get_valid_record |
493 | assert_deprecated { assert_valid assigns('record') } |
494 | end |
495 | |
496 | def test_assert_valid_failing |
497 | get :get_invalid_record |
498 | |
499 | begin |
500 | assert_deprecated { assert_valid assigns('record') } |
501 | assert false |
502 | rescue ActiveSupport::TestCase::Assertion => e |
503 | end |
504 | end |
505 | |
506 | def test_assert_response_uses_exception_message |
507 | @controller = AssertResponseWithUnexpectedErrorController.new |
508 | get :index |
509 | assert_response :success |
510 | flunk 'Expected non-success response' |
511 | rescue ActiveSupport::TestCase::Assertion => e |
512 | assert e.message.include?('FAIL') |
513 | end |
514 | |
515 | def test_assert_response_failure_response_with_no_exception |
516 | @controller = AssertResponseWithUnexpectedErrorController.new |
517 | get :show |
518 | assert_response :success |
519 | flunk 'Expected non-success response' |
520 | rescue ActiveSupport::TestCase::Assertion |
521 | # success |
522 | rescue |
523 | flunk "assert_response failed to handle failure response with missing, but optional, exception." |
524 | end |
525 | end |
526 | |
527 | class ActionPackHeaderTest < ActionController::TestCase |
528 | tests ActionPackAssertionsController |
529 | |
530 | def test_rendering_xml_sets_content_type |
531 | process :hello_xml_world |
532 | assert_equal('application/xml; charset=utf-8', @response.headers['Content-Type']) |
533 | end |
534 | |
535 | def test_rendering_xml_respects_content_type |
536 | @response.headers['type'] = 'application/pdf' |
537 | process :hello_xml_world |
538 | assert_equal('application/pdf; charset=utf-8', @response.headers['Content-Type']) |
539 | end |
540 | |
541 | def test_render_text_with_custom_content_type |
542 | get :render_text_with_custom_content_type |
543 | assert_equal 'application/rss+xml; charset=utf-8', @response.headers['Content-Type'] |
544 | end |
545 | end |