actionpack_csi 2.3.5.p6

data/test/controller/action_pack_assertions_test.rb

@@ -0,0 +1,543 @@
+require 'abstract_unit'
+
+# a controller class to facilitate the tests
+class ActionPackAssertionsController < ActionController::Base
+
+  # this does absolutely nothing
+  def nothing() head :ok end
+
+  # a standard template
+  def hello_world() render :template => "test/hello_world"; end
+
+  # a standard template
+  def hello_xml_world() render :template => "test/hello_xml_world"; end
+  
+  # a standard partial
+  def partial() render :partial => 'test/partial'; end
+
+  # a redirect to an internal location
+  def redirect_internal() redirect_to "/nothing"; end
+
+  def redirect_to_action() redirect_to :action => "flash_me", :id => 1, :params => { "panda" => "fun" }; end
+
+  def redirect_to_controller() redirect_to :controller => "elsewhere", :action => "flash_me"; end
+
+  def redirect_to_controller_with_symbol() redirect_to :controller => :elsewhere, :action => :flash_me; end
+
+  def redirect_to_path() redirect_to '/some/path' end
+
+  def redirect_to_named_route() redirect_to route_one_url end
+
+  # a redirect to an external location
+  def redirect_external() redirect_to "http://www.rubyonrails.org"; end
+
+  # a 404
+  def response404() head '404 AWOL' end
+
+  # a 500
+  def response500() head '500 Sorry' end
+
+  # a fictional 599
+  def response599() head '599 Whoah!' end
+
+  # putting stuff in the flash
+  def flash_me
+    flash['hello'] = 'my name is inigo montoya...'
+    render :text => "Inconceivable!"
+  end
+
+  # we have a flash, but nothing is in it
+  def flash_me_naked
+    flash.clear
+    render :text => "wow!"
+  end
+
+  # assign some template instance variables
+  def assign_this
+    @howdy = "ho"
+    render :inline => "Mr. Henke"
+  end
+
+  def render_based_on_parameters
+    render :text => "Mr. #{params[:name]}"
+  end
+
+  def render_url
+    render :text => "<div>#{url_for(:action => 'flash_me', :only_path => true)}</div>"
+  end
+
+  def render_text_with_custom_content_type
+    render :text => "Hello!", :content_type => Mime::RSS
+  end
+
+  # puts something in the session
+  def session_stuffing
+    session['xmas'] = 'turkey'
+    render :text => "ho ho ho"
+  end
+
+  # raises exception on get requests
+  def raise_on_get
+    raise "get" if request.get?
+    render :text => "request method: #{request.env['REQUEST_METHOD']}"
+  end
+
+  # raises exception on post requests
+  def raise_on_post
+    raise "post" if request.post?
+    render :text => "request method: #{request.env['REQUEST_METHOD']}"
+  end
+
+  def get_valid_record
+    @record = Class.new do
+      def valid?
+        true
+      end
+
+      def errors
+        Class.new do
+           def full_messages; []; end
+        end.new
+      end
+
+    end.new
+
+    render :nothing => true
+  end
+
+
+  def get_invalid_record
+    @record = Class.new do
+
+      def valid?
+        false
+      end
+
+      def errors
+        Class.new do
+           def full_messages; ['...stuff...']; end
+        end.new
+      end
+    end.new
+
+    render :nothing => true
+  end
+
+  # 911
+  def rescue_action(e) raise; end
+end
+
+# Used to test that assert_response includes the exception message
+# in the failure message when an action raises and assert_response
+# is expecting something other than an error.
+class AssertResponseWithUnexpectedErrorController < ActionController::Base
+  def index
+    raise 'FAIL'
+  end
+
+  def show
+    render :text => "Boom", :status => 500
+  end
+end
+
+class UserController < ActionController::Base
+end
+
+module Admin
+  class InnerModuleController < ActionController::Base
+    def index
+      render :nothing => true
+    end
+
+    def redirect_to_index
+      redirect_to admin_inner_module_path
+    end
+
+    def redirect_to_absolute_controller
+      redirect_to :controller => '/content'
+    end
+
+    def redirect_to_fellow_controller
+      redirect_to :controller => 'user'
+    end
+
+    def redirect_to_top_level_named_route
+      redirect_to top_level_url(:id => "foo")
+    end
+  end
+end
+
+# a test case to exercise the new capabilities TestRequest & TestResponse
+class ActionPackAssertionsControllerTest < ActionController::TestCase
+  # let's get this party started
+  def setup
+    ActionController::Routing::Routes.reload
+    ActionController::Routing.use_controllers!(%w(action_pack_assertions admin/inner_module user content admin/user))
+  end
+
+  def teardown
+    ActionController::Routing::Routes.reload
+  end
+
+  # -- assertion-based testing ------------------------------------------------
+
+  def test_assert_tag_and_url_for
+    get :render_url
+    assert_tag :content => "/action_pack_assertions/flash_me"
+  end
+
+  # test the get method, make sure the request really was a get
+  def test_get
+    assert_raise(RuntimeError) { get :raise_on_get }
+    get :raise_on_post
+    assert_equal @response.body, 'request method: GET'
+  end
+
+  # test the get method, make sure the request really was a get
+  def test_post
+    assert_raise(RuntimeError) { post :raise_on_post }
+    post :raise_on_get
+    assert_equal @response.body, 'request method: POST'
+  end
+
+#   the following test fails because the request_method is now cached on the request instance
+#   test the get/post switch within one test action
+#   def test_get_post_switch
+#     post :raise_on_get
+#     assert_equal @response.body, 'request method: POST'
+#     get :raise_on_post
+#     assert_equal @response.body, 'request method: GET'
+#     post :raise_on_get
+#     assert_equal @response.body, 'request method: POST'
+#     get :raise_on_post
+#     assert_equal @response.body, 'request method: GET'
+#   end
+
+  # test the redirection to a named route
+  def test_assert_redirect_to_named_route
+    with_routing do |set|
+      set.draw do |map|
+        map.route_one 'route_one', :controller => 'action_pack_assertions', :action => 'nothing'
+        map.connect   ':controller/:action/:id'
+      end
+      set.install_helpers
+
+      process :redirect_to_named_route
+      assert_redirected_to 'http://test.host/route_one'
+      assert_redirected_to route_one_url
+    end
+  end
+
+  def test_assert_redirect_to_named_route_failure
+    with_routing do |set|
+      set.draw do |map|
+        map.route_one 'route_one', :controller => 'action_pack_assertions', :action => 'nothing', :id => 'one'
+        map.route_two 'route_two', :controller => 'action_pack_assertions', :action => 'nothing', :id => 'two'
+        map.connect   ':controller/:action/:id'
+      end
+      process :redirect_to_named_route
+      assert_raise(ActiveSupport::TestCase::Assertion) do
+        assert_redirected_to 'http://test.host/route_two'
+      end
+      assert_raise(ActiveSupport::TestCase::Assertion) do
+        assert_redirected_to :controller => 'action_pack_assertions', :action => 'nothing', :id => 'two'
+      end
+      assert_raise(ActiveSupport::TestCase::Assertion) do
+        assert_redirected_to route_two_url
+      end
+    end
+  end
+
+  def test_assert_redirect_to_nested_named_route
+    with_routing do |set|
+      set.draw do |map|
+        map.admin_inner_module 'admin/inner_module', :controller => 'admin/inner_module', :action => 'index'
+        map.connect            ':controller/:action/:id'
+      end
+      @controller = Admin::InnerModuleController.new
+      process :redirect_to_index
+      # redirection is <{"action"=>"index", "controller"=>"admin/admin/inner_module"}>
+      assert_redirected_to admin_inner_module_path
+    end
+  end
+
+  def test_assert_redirected_to_top_level_named_route_from_nested_controller
+    with_routing do |set|
+      set.draw do |map|
+        map.top_level '/action_pack_assertions/:id', :controller => 'action_pack_assertions', :action => 'index'
+        map.connect   ':controller/:action/:id'
+      end
+      @controller = Admin::InnerModuleController.new
+      process :redirect_to_top_level_named_route
+      # assert_redirected_to "http://test.host/action_pack_assertions/foo" would pass because of exact match early return
+      assert_redirected_to "/action_pack_assertions/foo"
+    end
+  end
+
+  def test_assert_redirected_to_top_level_named_route_with_same_controller_name_in_both_namespaces
+    with_routing do |set|
+      set.draw do |map|
+        # this controller exists in the admin namespace as well which is the only difference from previous test
+        map.top_level '/user/:id', :controller => 'user', :action => 'index'
+        map.connect   ':controller/:action/:id'
+      end
+      @controller = Admin::InnerModuleController.new
+      process :redirect_to_top_level_named_route
+      # assert_redirected_to top_level_url('foo') would pass because of exact match early return
+      assert_redirected_to top_level_path('foo')
+    end
+  end
+
+  # -- standard request/response object testing --------------------------------
+
+  # make sure that the template objects exist
+  def test_template_objects_alive
+    process :assign_this
+    assert !@response.has_template_object?('hi')
+    assert @response.has_template_object?('howdy')
+  end
+
+  # make sure we don't have template objects when we shouldn't
+  def test_template_object_missing
+    process :nothing
+    assert_nil @response.template_objects['howdy']
+  end
+
+  # check the empty flashing
+  def test_flash_me_naked
+    process :flash_me_naked
+    assert !@response.has_flash?
+    assert !@response.has_flash_with_contents?
+  end
+
+  # check if we have flash objects
+  def test_flash_haves
+    process :flash_me
+    assert @response.has_flash?
+    assert @response.has_flash_with_contents?
+    assert @response.has_flash_object?('hello')
+  end
+
+  # ensure we don't have flash objects
+  def test_flash_have_nots
+    process :nothing
+    assert !@response.has_flash?
+    assert !@response.has_flash_with_contents?
+    assert_nil @response.flash['hello']
+  end
+
+  # check if we were rendered by a file-based template?
+  def test_rendered_action
+    process :nothing
+    assert_nil @response.rendered[:template]
+
+    process :hello_world
+    assert @response.rendered[:template]
+    assert 'hello_world', @response.rendered[:template].to_s
+  end
+  
+  def test_assert_template_with_partial
+    get :partial
+    assert_template :partial => '_partial'
+  end
+  
+  def test_assert_template_with_nil
+    get :nothing
+    assert_template nil
+  end
+  
+  def test_assert_template_with_string
+    get :hello_world
+    assert_template 'hello_world'    
+  end
+  
+  def test_assert_template_with_symbol
+    get :hello_world
+    assert_template :hello_world
+  end
+  
+  def test_assert_template_with_bad_argument
+    assert_raise(ArgumentError) { assert_template 1 }    
+  end
+
+  # check the redirection location
+  def test_redirection_location
+    process :redirect_internal
+    assert_equal 'http://test.host/nothing', @response.redirect_url
+
+    process :redirect_external
+    assert_equal 'http://www.rubyonrails.org', @response.redirect_url
+  end
+
+  def test_no_redirect_url
+    process :nothing
+    assert_nil @response.redirect_url
+  end
+
+
+  # check server errors
+  def test_server_error_response_code
+    process :response500
+    assert @response.server_error?
+
+    process :response599
+    assert @response.server_error?
+
+    process :response404
+    assert !@response.server_error?
+  end
+
+  # check a 404 response code
+  def test_missing_response_code
+    process :response404
+    assert @response.missing?
+  end
+
+  # check client errors
+  def test_client_error_response_code
+    process :response404
+    assert @response.client_error?
+  end
+
+  # check to see if our redirection matches a pattern
+  def test_redirect_url_match
+    process :redirect_external
+    assert @response.redirect?
+    assert @response.redirect_url_match?("rubyonrails")
+    assert @response.redirect_url_match?(/rubyonrails/)
+    assert !@response.redirect_url_match?("phpoffrails")
+    assert !@response.redirect_url_match?(/perloffrails/)
+  end
+
+  # check for a redirection
+  def test_redirection
+    process :redirect_internal
+    assert @response.redirect?
+
+    process :redirect_external
+    assert @response.redirect?
+
+    process :nothing
+    assert !@response.redirect?
+  end
+
+  # check a successful response code
+  def test_successful_response_code
+    process :nothing
+    assert @response.success?
+  end
+
+  # a basic check to make sure we have a TestResponse object
+  def test_has_response
+    process :nothing
+    assert_kind_of ActionController::TestResponse, @response
+  end
+
+  def test_render_based_on_parameters
+    process :render_based_on_parameters, "name" => "David"
+    assert_equal "Mr. David", @response.body
+  end
+
+
+  def test_assert_redirection_fails_with_incorrect_controller
+    process :redirect_to_controller
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_redirected_to :controller => "action_pack_assertions", :action => "flash_me"
+    end
+  end
+
+  def test_assert_redirection_with_extra_controller_option
+    get :redirect_to_action
+    assert_redirected_to :controller => 'action_pack_assertions', :action => "flash_me", :id => 1, :params => { :panda => 'fun' }
+  end
+
+  def test_redirected_to_url_leading_slash
+    process :redirect_to_path
+    assert_redirected_to '/some/path'
+  end
+
+  def test_redirected_to_url_no_leadling_slash
+    process :redirect_to_path
+    assert_redirected_to 'some/path'
+  end
+
+  def test_redirected_to_url_full_url
+    process :redirect_to_path
+    assert_redirected_to 'http://test.host/some/path'
+  end
+
+  def test_assert_redirection_with_symbol
+    process :redirect_to_controller_with_symbol
+    assert_nothing_raised {
+      assert_redirected_to :controller => "elsewhere", :action => "flash_me"
+    }
+    process :redirect_to_controller_with_symbol
+    assert_nothing_raised {
+      assert_redirected_to :controller => :elsewhere, :action => :flash_me
+    }
+  end
+
+  def test_redirected_to_with_nested_controller
+    @controller = Admin::InnerModuleController.new
+    get :redirect_to_absolute_controller
+    assert_redirected_to :controller => '/content'
+
+    get :redirect_to_fellow_controller
+    assert_redirected_to :controller => 'admin/user'
+  end
+
+  def test_assert_valid
+    get :get_valid_record
+    assert_deprecated { assert_valid assigns('record') }
+  end
+
+  def test_assert_valid_failing
+    get :get_invalid_record
+
+    begin
+      assert_deprecated { assert_valid assigns('record') }
+      assert false
+    rescue ActiveSupport::TestCase::Assertion => e
+    end
+  end
+
+  def test_assert_response_uses_exception_message
+    @controller = AssertResponseWithUnexpectedErrorController.new
+    get :index
+    assert_response :success
+    flunk 'Expected non-success response'
+  rescue ActiveSupport::TestCase::Assertion => e
+    assert e.message.include?('FAIL')
+  end
+
+  def test_assert_response_failure_response_with_no_exception
+    @controller = AssertResponseWithUnexpectedErrorController.new
+    get :show
+    assert_response :success
+    flunk 'Expected non-success response'
+  rescue ActiveSupport::TestCase::Assertion
+    # success
+  rescue
+    flunk "assert_response failed to handle failure response with missing, but optional, exception."
+  end
+end
+
+class ActionPackHeaderTest < ActionController::TestCase
+  tests ActionPackAssertionsController
+
+  def test_rendering_xml_sets_content_type
+    process :hello_xml_world
+    assert_equal('application/xml; charset=utf-8', @response.headers['Content-Type'])
+  end
+
+  def test_rendering_xml_respects_content_type
+    @response.headers['type'] = 'application/pdf'
+    process :hello_xml_world
+    assert_equal('application/pdf; charset=utf-8', @response.headers['Content-Type'])
+  end
+
+  def test_render_text_with_custom_content_type
+    get :render_text_with_custom_content_type
+    assert_equal 'application/rss+xml; charset=utf-8', @response.headers['Content-Type']
+  end
+end

data/test/controller/addresses_render_test.rb

@@ -0,0 +1,37 @@
+require 'abstract_unit'
+
+class Address
+  def Address.count(conditions = nil, join = nil)
+    nil
+  end
+
+  def Address.find_all(arg1, arg2, arg3, arg4)
+    []
+  end
+
+  def self.find(*args)
+    []
+  end
+end
+
+class AddressesTestController < ActionController::Base
+  def self.controller_name; "addresses"; end
+  def self.controller_path; "addresses"; end
+end
+
+class AddressesTest < ActionController::TestCase
+  tests AddressesTestController
+
+  def setup
+    # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
+    # a more accurate simulation of what happens in "real life".
+    @controller.logger = Logger.new(nil)
+
+    @request.host = "www.nextangle.com"
+  end
+
+  def test_list
+    get :list
+    assert_equal "We only need to get this far!", @response.body.chomp
+  end
+end