vendor/rails/actionpack/test/controller/test_test.rb

   1 require 'abstract_unit'
   2 require 'controller/fake_controllers'
   3
   4 class TestTest < ActionController::TestCase
   5   class TestController < ActionController::Base
   6     def no_op
   7       render :text => 'dummy'
   8     end
   9
  10     def set_flash
  11       flash["test"] = ">#{flash["test"]}<"
  12       render :text => 'ignore me'
  13     end
  14
  15     def set_flash_now
  16       flash.now["test_now"] = ">#{flash["test_now"]}<"
  17       render :text => 'ignore me'
  18     end
  19
  20     def set_session
  21       session['string'] = 'A wonder'
  22       session[:symbol] = 'it works'
  23       render :text => 'Success'
  24     end
  25
  26     def reset_the_session
  27       reset_session
  28       render :text => 'ignore me'
  29     end
  30
  31     def render_raw_post
  32       raise ActiveSupport::TestCase::Assertion, "#raw_post is blank" if request.raw_post.blank?
  33       render :text => request.raw_post
  34     end
  35
  36     def render_body
  37       render :text => request.body.read
  38     end
  39
  40     def test_params
  41       render :text => params.inspect
  42     end
  43
  44     def test_uri
  45       render :text => request.request_uri
  46     end
  47
  48     def test_query_string
  49       render :text => request.query_string
  50     end
  51
  52     def test_html_output
  53       render :text => <<HTML
  54 <html>
  55   <body>
  56     <a href="/"><img src="/images/button.png" /></a>
  57     <div id="foo">
  58       <ul>
  59         <li class="item">hello</li>
  60         <li class="item">goodbye</li>
  61       </ul>
  62     </div>
  63     <div id="bar">
  64       <form action="/somewhere">
  65         Name: <input type="text" name="person[name]" id="person_name" />
  66       </form>
  67     </div>
  68   </body>
  69 </html>
  70 HTML
  71     end
  72
  73     def test_xml_output
  74       response.content_type = "application/xml"
  75       render :text => <<XML
  76 <?xml version="1.0" encoding="UTF-8"?>
  77 <root>
  78   <area>area is an empty tag in HTML, raising an error if not in xml mode</area>
  79 </root>
  80 XML
  81     end
  82
  83     def test_only_one_param
  84       render :text => (params[:left] && params[:right]) ? "EEP, Both here!" : "OK"
  85     end
  86
  87     def test_remote_addr
  88       render :text => (request.remote_addr || "not specified")
  89     end
  90
  91     def test_file_upload
  92       render :text => params[:file].size
  93     end
  94
  95     def test_send_file
  96       send_file(File.expand_path(__FILE__))
  97     end
  98
  99     def redirect_to_same_controller
 100       redirect_to :controller => 'test', :action => 'test_uri', :id => 5
 101     end
 102
 103     def redirect_to_different_controller
 104       redirect_to :controller => 'fail', :id => 5
 105     end
 106
 107     def create
 108       head :created, :location => 'created resource'
 109     end
 110
 111     private
 112       def rescue_action(e)
 113         raise e
 114       end
 115
 116       def generate_url(opts)
 117         url_for(opts.merge(:action => "test_uri"))
 118       end
 119   end
 120
 121   def setup
 122     @controller = TestController.new
 123     @request    = ActionController::TestRequest.new
 124     @response   = ActionController::TestResponse.new
 125     ActionController::Routing.use_controllers! %w(content admin/user test_test/test)
 126     ActionController::Routing::Routes.load_routes!
 127   end
 128
 129   def teardown
 130     ActionController::Routing::Routes.reload
 131   end
 132
 133   def test_raw_post_handling
 134     params = {:page => {:name => 'page name'}, 'some key' => 123}
 135     post :render_raw_post, params.dup
 136
 137     assert_equal params.to_query, @response.body
 138   end
 139
 140   def test_body_stream
 141     params = { :page => { :name => 'page name' }, 'some key' => 123 }
 142
 143     post :render_body, params.dup
 144
 145     assert_equal params.to_query, @response.body
 146   end
 147
 148   def test_process_without_flash
 149     process :set_flash
 150     assert_equal '><', flash['test']
 151   end
 152
 153   def test_process_with_flash
 154     process :set_flash, nil, nil, { "test" => "value" }
 155     assert_equal '>value<', flash['test']
 156   end
 157
 158   def test_process_with_flash_now
 159     process :set_flash_now, nil, nil, { "test_now" => "value_now" }
 160     assert_equal '>value_now<', flash['test_now']
 161   end
 162
 163   def test_process_with_session
 164     process :set_session
 165     assert_equal 'A wonder', session['string'], "A value stored in the session should be available by string key"
 166     assert_equal 'A wonder', session[:string], "Test session hash should allow indifferent access"
 167     assert_equal 'it works', session['symbol'], "Test session hash should allow indifferent access"
 168     assert_equal 'it works', session[:symbol], "Test session hash should allow indifferent access"
 169   end
 170
 171   def test_process_with_session_arg
 172     process :no_op, nil, { 'string' => 'value1', :symbol => 'value2' }
 173     assert_equal 'value1', session['string']
 174     assert_equal 'value1', session[:string]
 175     assert_equal 'value2', session['symbol']
 176     assert_equal 'value2', session[:symbol]
 177   end
 178
 179   def test_session_is_cleared_from_controller_after_reset_session
 180     process :set_session
 181     process :reset_the_session
 182     assert_equal Hash.new, @controller.session.to_hash
 183   end
 184
 185   def test_session_is_cleared_from_response_after_reset_session
 186     process :set_session
 187     process :reset_the_session
 188     assert_equal Hash.new, @response.session.to_hash
 189   end
 190
 191   def test_session_is_cleared_from_request_after_reset_session
 192     process :set_session
 193     process :reset_the_session
 194     assert_equal Hash.new, @request.session.to_hash
 195   end
 196
 197   def test_process_with_request_uri_with_no_params
 198     process :test_uri
 199     assert_equal "/test_test/test/test_uri", @response.body
 200   end
 201
 202   def test_process_with_request_uri_with_params
 203     process :test_uri, :id => 7
 204     assert_equal "/test_test/test/test_uri/7", @response.body
 205   end
 206
 207   def test_process_with_request_uri_with_params_with_explicit_uri
 208     @request.set_REQUEST_URI "/explicit/uri"
 209     process :test_uri, :id => 7
 210     assert_equal "/explicit/uri", @response.body
 211   end
 212
 213   def test_process_with_query_string
 214     process :test_query_string, :q => 'test'
 215     assert_equal "q=test", @response.body
 216   end
 217
 218   def test_process_with_query_string_with_explicit_uri
 219     @request.set_REQUEST_URI "/explicit/uri?q=test?extra=question"
 220     process :test_query_string
 221     assert_equal "q=test?extra=question", @response.body
 222   end
 223
 224   def test_multiple_calls
 225     process :test_only_one_param, :left => true
 226     assert_equal "OK", @response.body
 227     process :test_only_one_param, :right => true
 228     assert_equal "OK", @response.body
 229   end
 230
 231   def test_assert_tag_tag
 232     process :test_html_output
 233
 234     # there is a 'form' tag
 235     assert_tag :tag => 'form'
 236     # there is not an 'hr' tag
 237     assert_no_tag :tag => 'hr'
 238   end
 239
 240   def test_assert_tag_attributes
 241     process :test_html_output
 242
 243     # there is a tag with an 'id' of 'bar'
 244     assert_tag :attributes => { :id => "bar" }
 245     # there is no tag with a 'name' of 'baz'
 246     assert_no_tag :attributes => { :name => "baz" }
 247   end
 248
 249   def test_assert_tag_parent
 250     process :test_html_output
 251
 252     # there is a tag with a parent 'form' tag
 253     assert_tag :parent => { :tag => "form" }
 254     # there is no tag with a parent of 'input'
 255     assert_no_tag :parent => { :tag => "input" }
 256   end
 257
 258   def test_assert_tag_child
 259     process :test_html_output
 260
 261     # there is a tag with a child 'input' tag
 262     assert_tag :child => { :tag => "input" }
 263     # there is no tag with a child 'strong' tag
 264     assert_no_tag :child => { :tag => "strong" }
 265   end
 266
 267   def test_assert_tag_ancestor
 268     process :test_html_output
 269
 270     # there is a 'li' tag with an ancestor having an id of 'foo'
 271     assert_tag :ancestor => { :attributes => { :id => "foo" } }, :tag => "li"
 272     # there is no tag of any kind with an ancestor having an href matching 'foo'
 273     assert_no_tag :ancestor => { :attributes => { :href => /foo/ } }
 274   end
 275
 276   def test_assert_tag_descendant
 277     process :test_html_output
 278
 279     # there is a tag with a descendant 'li' tag
 280     assert_tag :descendant => { :tag => "li" }
 281     # there is no tag with a descendant 'html' tag
 282     assert_no_tag :descendant => { :tag => "html" }
 283   end
 284
 285   def test_assert_tag_sibling
 286     process :test_html_output
 287
 288     # there is a tag with a sibling of class 'item'
 289     assert_tag :sibling => { :attributes => { :class => "item" } }
 290     # there is no tag with a sibling 'ul' tag
 291     assert_no_tag :sibling => { :tag => "ul" }
 292   end
 293
 294   def test_assert_tag_after
 295     process :test_html_output
 296
 297     # there is a tag following a sibling 'div' tag
 298     assert_tag :after => { :tag => "div" }
 299     # there is no tag following a sibling tag with id 'bar'
 300     assert_no_tag :after => { :attributes => { :id => "bar" } }
 301   end
 302
 303   def test_assert_tag_before
 304     process :test_html_output
 305
 306     # there is a tag preceding a tag with id 'bar'
 307     assert_tag :before => { :attributes => { :id => "bar" } }
 308     # there is no tag preceding a 'form' tag
 309     assert_no_tag :before => { :tag => "form" }
 310   end
 311
 312   def test_assert_tag_children_count
 313     process :test_html_output
 314
 315     # there is a tag with 2 children
 316     assert_tag :children => { :count => 2 }
 317     # in particular, there is a <ul> tag with two children (a nameless pair of <li>s)
 318     assert_tag :tag => 'ul', :children => { :count => 2 }
 319     # there is no tag with 4 children
 320     assert_no_tag :children => { :count => 4 }
 321   end
 322
 323   def test_assert_tag_children_less_than
 324     process :test_html_output
 325
 326     # there is a tag with less than 5 children
 327     assert_tag :children => { :less_than => 5 }
 328     # there is no 'ul' tag with less than 2 children
 329     assert_no_tag :children => { :less_than => 2 }, :tag => "ul"
 330   end
 331
 332   def test_assert_tag_children_greater_than
 333     process :test_html_output
 334
 335     # there is a 'body' tag with more than 1 children
 336     assert_tag :children => { :greater_than => 1 }, :tag => "body"
 337     # there is no tag with more than 10 children
 338     assert_no_tag :children => { :greater_than => 10 }
 339   end
 340
 341   def test_assert_tag_children_only
 342     process :test_html_output
 343
 344     # there is a tag containing only one child with an id of 'foo'
 345     assert_tag :children => { :count => 1,
 346                               :only => { :attributes => { :id => "foo" } } }
 347     # there is no tag containing only one 'li' child
 348     assert_no_tag :children => { :count => 1, :only => { :tag => "li" } }
 349   end
 350
 351   def test_assert_tag_content
 352     process :test_html_output
 353
 354     # the output contains the string "Name"
 355     assert_tag :content => /Name/
 356     # the output does not contain the string "test"
 357     assert_no_tag :content => /test/
 358   end
 359
 360   def test_assert_tag_multiple
 361     process :test_html_output
 362
 363     # there is a 'div', id='bar', with an immediate child whose 'action'
 364     # attribute matches the regexp /somewhere/.
 365     assert_tag :tag => "div", :attributes => { :id => "bar" },
 366                :child => { :attributes => { :action => /somewhere/ } }
 367
 368     # there is no 'div', id='foo', with a 'ul' child with more than
 369     # 2 "li" children.
 370     assert_no_tag :tag => "div", :attributes => { :id => "foo" },
 371                   :child => {
 372                     :tag => "ul",
 373                     :children => { :greater_than => 2,
 374                                    :only => { :tag => "li" } } }
 375   end
 376
 377   def test_assert_tag_children_without_content
 378     process :test_html_output
 379
 380     # there is a form tag with an 'input' child which is a self closing tag
 381     assert_tag :tag => "form",
 382       :children => { :count => 1,
 383         :only => { :tag => "input" } }
 384
 385     # the body tag has an 'a' child which in turn has an 'img' child
 386     assert_tag :tag => "body",
 387       :children => { :count => 1,
 388         :only => { :tag => "a",
 389           :children => { :count => 1,
 390             :only => { :tag => "img" } } } }
 391   end
 392
 393   def test_should_not_impose_childless_html_tags_in_xml
 394     process :test_xml_output
 395
 396     begin
 397       $stderr = StringIO.new
 398       assert_select 'area' #This will cause a warning if content is processed as HTML
 399       $stderr.rewind && err = $stderr.read
 400     ensure
 401       $stderr = STDERR
 402     end
 403
 404     assert err.empty?
 405   end
 406
 407   def test_assert_tag_attribute_matching
 408     @response.body = '<input type="text" name="my_name">'
 409     assert_tag :tag => 'input',
 410                  :attributes => { :name => /my/, :type => 'text' }
 411     assert_no_tag :tag => 'input',
 412                  :attributes => { :name => 'my', :type => 'text' }
 413     assert_no_tag :tag => 'input',
 414                  :attributes => { :name => /^my$/, :type => 'text' }
 415   end
 416
 417   def test_assert_tag_content_matching
 418     @response.body = "<p>hello world</p>"
 419     assert_tag :tag => "p", :content => "hello world"
 420     assert_tag :tag => "p", :content => /hello/
 421     assert_no_tag :tag => "p", :content => "hello"
 422   end
 423
 424   def test_assert_generates
 425     assert_generates 'controller/action/5', :controller => 'controller', :action => 'action', :id => '5'
 426     assert_generates 'controller/action/7', {:id => "7"}, {:controller => "controller", :action => "action"}
 427     assert_generates 'controller/action/5', {:controller => "controller", :action => "action", :id => "5", :name => "bob"}, {}, {:name => "bob"}
 428     assert_generates 'controller/action/7', {:id => "7", :name => "bob"}, {:controller => "controller", :action => "action"}, {:name => "bob"}
 429     assert_generates 'controller/action/7', {:id => "7"}, {:controller => "controller", :action => "action", :name => "bob"}, {}
 430   end
 431
 432   def test_assert_routing
 433     assert_routing 'content', :controller => 'content', :action => 'index'
 434   end
 435
 436   def test_assert_routing_with_method
 437     with_routing do |set|
 438       set.draw { |map| map.resources(:content) }
 439       assert_routing({ :method => 'post', :path => 'content' }, { :controller => 'content', :action => 'create' })
 440     end
 441   end
 442
 443   def test_assert_routing_in_module
 444     assert_routing 'admin/user', :controller => 'admin/user', :action => 'index'
 445   end
 446
 447   def test_params_passing
 448     get :test_params, :page => {:name => "Page name", :month => '4', :year => '2004', :day => '6'}
 449     parsed_params = eval(@response.body)
 450     assert_equal(
 451       {'controller' => 'test_test/test', 'action' => 'test_params',
 452        'page' => {'name' => "Page name", 'month' => '4', 'year' => '2004', 'day' => '6'}},
 453       parsed_params
 454     )
 455   end
 456
 457   def test_id_converted_to_string
 458     get :test_params, :id => 20, :foo => Object.new
 459     assert_kind_of String, @request.path_parameters['id']
 460   end
 461
 462   def test_array_path_parameter_handled_properly
 463     with_routing do |set|
 464       set.draw do |map|
 465         map.connect 'file/*path', :controller => 'test_test/test', :action => 'test_params'
 466         map.connect ':controller/:action/:id'
 467       end
 468
 469       get :test_params, :path => ['hello', 'world']
 470       assert_equal ['hello', 'world'], @request.path_parameters['path']
 471       assert_equal 'hello/world', @request.path_parameters['path'].to_s
 472     end
 473   end
 474
 475   def test_assert_realistic_path_parameters
 476     get :test_params, :id => 20, :foo => Object.new
 477
 478     # All elements of path_parameters should use string keys
 479     @request.path_parameters.keys.each do |key|
 480       assert_kind_of String, key
 481     end
 482   end
 483
 484   def test_with_routing_places_routes_back
 485     assert ActionController::Routing::Routes
 486     routes_id = ActionController::Routing::Routes.object_id
 487
 488     begin
 489       with_routing { raise 'fail' }
 490       fail 'Should not be here.'
 491     rescue RuntimeError
 492     end
 493
 494     assert ActionController::Routing::Routes
 495     assert_equal routes_id, ActionController::Routing::Routes.object_id
 496   end
 497
 498   def test_remote_addr
 499     get :test_remote_addr
 500     assert_equal "0.0.0.0", @response.body
 501
 502     @request.remote_addr = "192.0.0.1"
 503     get :test_remote_addr
 504     assert_equal "192.0.0.1", @response.body
 505   end
 506
 507   def test_header_properly_reset_after_remote_http_request
 508     xhr :get, :test_params
 509     assert_nil @request.env['HTTP_X_REQUESTED_WITH']
 510   end
 511
 512   def test_header_properly_reset_after_get_request
 513     get :test_params
 514     @request.recycle!
 515     assert_nil @request.instance_variable_get("@request_method")
 516   end
 517
 518   %w(controller response request).each do |variable|
 519     %w(get post put delete head process).each do |method|
 520       define_method("test_#{variable}_missing_for_#{method}_raises_error") do
 521         remove_instance_variable "@#{variable}"
 522         begin
 523           send(method, :test_remote_addr)
 524           assert false, "expected RuntimeError, got nothing"
 525         rescue RuntimeError => error
 526           assert true
 527           assert_match %r{@#{variable} is nil}, error.message
 528         rescue => error
 529           assert false, "expected RuntimeError, got #{error.class}"
 530         end
 531       end
 532     end
 533   end
 534
 535   FILES_DIR = File.dirname(__FILE__) + '/../fixtures/multipart'
 536
 537   if RUBY_VERSION < '1.9'
 538     READ_BINARY = 'rb'
 539     READ_PLAIN = 'r'
 540   else
 541     READ_BINARY = 'rb:binary'
 542     READ_PLAIN = 'r:binary'
 543   end
 544
 545   def test_test_uploaded_file
 546     filename = 'mona_lisa.jpg'
 547     path = "#{FILES_DIR}/#{filename}"
 548     content_type = 'image/png'
 549     expected = File.read(path)
 550     expected.force_encoding(Encoding::BINARY) if expected.respond_to?(:force_encoding)
 551
 552     file = ActionController::TestUploadedFile.new(path, content_type)
 553     assert_equal filename, file.original_filename
 554     assert_equal content_type, file.content_type
 555     assert_equal file.path, file.local_path
 556     assert_equal expected, file.read
 557
 558     new_content_type = "new content_type"
 559     file.content_type = new_content_type
 560     assert_equal new_content_type, file.content_type
 561
 562   end
 563
 564   def test_test_uploaded_file_with_binary
 565     filename = 'mona_lisa.jpg'
 566     path = "#{FILES_DIR}/#{filename}"
 567     content_type = 'image/png'
 568
 569     binary_uploaded_file = ActionController::TestUploadedFile.new(path, content_type, :binary)
 570     assert_equal File.open(path, READ_BINARY).read, binary_uploaded_file.read
 571
 572     plain_uploaded_file = ActionController::TestUploadedFile.new(path, content_type)
 573     assert_equal File.open(path, READ_PLAIN).read, plain_uploaded_file.read
 574   end
 575
 576   def test_fixture_file_upload_with_binary
 577     filename = 'mona_lisa.jpg'
 578     path = "#{FILES_DIR}/#{filename}"
 579     content_type = 'image/jpg'
 580
 581     binary_file_upload = fixture_file_upload(path, content_type, :binary)
 582     assert_equal File.open(path, READ_BINARY).read, binary_file_upload.read
 583
 584     plain_file_upload = fixture_file_upload(path, content_type)
 585     assert_equal File.open(path, READ_PLAIN).read, plain_file_upload.read
 586   end
 587
 588   def test_fixture_file_upload
 589     post :test_file_upload, :file => fixture_file_upload(FILES_DIR + "/mona_lisa.jpg", "image/jpg")
 590     assert_equal '159528', @response.body
 591   end
 592
 593   def test_test_uploaded_file_exception_when_file_doesnt_exist
 594     assert_raise(RuntimeError) { ActionController::TestUploadedFile.new('non_existent_file') }
 595   end
 596
 597   def test_redirect_url_only_cares_about_location_header
 598     get :create
 599     assert_response :created
 600
 601     # Redirect url doesn't care that it wasn't a :redirect response.
 602     assert_equal 'created resource', @response.redirect_url
 603     assert_equal @response.redirect_url, redirect_to_url
 604
 605     # Must be a :redirect response.
 606     assert_raise(ActiveSupport::TestCase::Assertion) do
 607       assert_redirected_to 'created resource'
 608     end
 609   end
 610
 611   def test_binary_content_works_with_send_file
 612     get :test_send_file
 613     assert_nothing_raised(NoMethodError) { @response.binary_content }
 614   end
 615
 616   protected
 617     def with_foo_routing
 618       with_routing do |set|
 619         set.draw do |map|
 620           map.generate_url 'foo', :controller => 'test'
 621           map.connect      ':controller/:action/:id'
 622         end
 623         yield set
 624       end
 625     end
 626 end
 627
 628 class CleanBacktraceTest < ActionController::TestCase
 629   def test_should_reraise_the_same_object
 630     exception = ActiveSupport::TestCase::Assertion.new('message')
 631     clean_backtrace { raise exception }
 632   rescue Exception => caught
 633     assert_equal exception.object_id, caught.object_id
 634     assert_equal exception.message, caught.message
 635   end
 636
 637   def test_should_clean_assertion_lines_from_backtrace
 638     path = File.expand_path("#{File.dirname(__FILE__)}/../../lib/action_controller")
 639     exception = ActiveSupport::TestCase::Assertion.new('message')
 640     exception.set_backtrace ["#{path}/abc", "#{path}/assertions/def"]
 641     clean_backtrace { raise exception }
 642   rescue Exception => caught
 643     assert_equal ["#{path}/abc"], caught.backtrace
 644   end
 645
 646   def test_should_only_clean_assertion_failure_errors
 647     clean_backtrace do
 648       raise "can't touch this", [File.expand_path("#{File.dirname(__FILE__)}/../../lib/action_controller/assertions/abc")]
 649     end
 650   rescue => caught
 651     assert !caught.backtrace.empty?
 652   end
 653 end
 654
 655 class InferringClassNameTest < ActionController::TestCase
 656   def test_determine_controller_class
 657     assert_equal ContentController, determine_class("ContentControllerTest")
 658   end
 659
 660   def test_determine_controller_class_with_nonsense_name
 661     assert_nil determine_class("HelloGoodBye")
 662   end
 663
 664   def test_determine_controller_class_with_sensible_name_where_no_controller_exists
 665     assert_nil determine_class("NoControllerWithThisNameTest")
 666   end
 667
 668   private
 669     def determine_class(name)
 670       ActionController::TestCase.determine_default_controller_class(name)
 671     end
 672 end
 673
 674 class CrazyNameTest < ActionController::TestCase
 675   tests ContentController
 676
 677   def test_controller_class_can_be_set_manually_not_just_inferred
 678     assert_equal ContentController, self.class.controller_class
 679   end
 680 end
 681
 682 class NamedRoutesControllerTest < ActionController::TestCase
 683   tests ContentController
 684
 685   def test_should_be_able_to_use_named_routes_before_a_request_is_done
 686     with_routing do |set|
 687       set.draw { |map| map.resources :contents }
 688       assert_equal 'http://test.host/contents/new', new_content_url
 689       assert_equal 'http://test.host/contents/1', content_url(:id => 1)
 690     end
 691   end
 692 end