actionpack_csi 2.3.5.p6

data/test/controller/capture_test.rb

@@ -0,0 +1,66 @@
+require 'abstract_unit'
+
+class CaptureController < ActionController::Base
+  def self.controller_name; "test"; end
+  def self.controller_path; "test"; end
+
+  def content_for
+    render :layout => "talk_from_action"
+  end
+
+  def content_for_with_parameter
+    render :layout => "talk_from_action"
+  end
+
+  def content_for_concatenated
+    render :layout => "talk_from_action"
+  end
+
+  def non_erb_block_content_for
+    render :layout => "talk_from_action"
+  end
+
+  def rescue_action(e) raise end
+end
+
+class CaptureTest < ActionController::TestCase
+  tests CaptureController
+
+  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_simple_capture
+    get :capturing
+    assert_equal "Dreamy days", @response.body.strip
+  end
+
+  def test_content_for
+    get :content_for
+    assert_equal expected_content_for_output, @response.body
+  end
+
+  def test_should_concatentate_content_for
+    get :content_for_concatenated
+    assert_equal expected_content_for_output, @response.body
+  end
+
+  def test_should_set_content_for_with_parameter
+    get :content_for_with_parameter
+    assert_equal expected_content_for_output, @response.body
+  end
+
+  def test_non_erb_block_content_for
+    get :non_erb_block_content_for
+    assert_equal expected_content_for_output, @response.body
+  end
+
+  private
+    def expected_content_for_output
+      "<title>Putting stuff in the title!</title>\n\nGreat stuff!"
+    end
+end

data/test/controller/content_type_test.rb

@@ -0,0 +1,168 @@
+require 'abstract_unit'
+
+class ContentTypeController < ActionController::Base
+  def render_content_type_from_body
+    response.content_type = Mime::RSS
+    render :text => "hello world!"
+  end
+
+  def render_defaults
+    render :text => "hello world!"
+  end
+
+  def render_content_type_from_render
+    render :text => "hello world!", :content_type => Mime::RSS
+  end
+
+  def render_charset_from_body
+    response.charset = "utf-16"
+    render :text => "hello world!"
+  end
+
+  def render_nil_charset_from_body
+    response.charset = nil
+    render :text => "hello world!"
+  end
+
+  def render_default_for_rhtml
+  end
+
+  def render_default_for_rxml
+  end
+
+  def render_default_for_rjs
+  end
+
+  def render_change_for_rxml
+    response.content_type = Mime::HTML
+    render :action => "render_default_for_rxml"
+  end
+
+  def render_default_content_types_for_respond_to
+    respond_to do |format|
+      format.html { render :text   => "hello world!" }
+      format.xml  { render :action => "render_default_content_types_for_respond_to.rhtml" }
+      format.js   { render :text   => "hello world!" }
+      format.rss  { render :text   => "hello world!", :content_type => Mime::XML }
+    end
+  end
+
+  def rescue_action(e) raise end
+end
+
+class ContentTypeTest < ActionController::TestCase
+  tests ContentTypeController
+
+  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)
+  end
+
+  def test_render_defaults
+    get :render_defaults
+    assert_equal "utf-8", @response.charset
+    assert_equal Mime::HTML, @response.content_type
+  end
+
+  def test_render_changed_charset_default
+    ContentTypeController.default_charset = "utf-16"
+    get :render_defaults
+    assert_equal "utf-16", @response.charset
+    assert_equal Mime::HTML, @response.content_type
+    ContentTypeController.default_charset = "utf-8"
+  end
+
+  def test_content_type_from_body
+    get :render_content_type_from_body
+    assert_equal "application/rss+xml", @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  def test_content_type_from_render
+    get :render_content_type_from_render
+    assert_equal "application/rss+xml", @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  def test_charset_from_body
+    get :render_charset_from_body
+    assert_equal Mime::HTML, @response.content_type
+    assert_equal "utf-16", @response.charset
+  end
+
+  def test_nil_charset_from_body
+    get :render_nil_charset_from_body
+    assert_equal Mime::HTML, @response.content_type
+    assert_equal "utf-8", @response.charset, @response.headers.inspect
+  end
+
+  def test_nil_default_for_rhtml
+    ContentTypeController.default_charset = nil
+    get :render_default_for_rhtml
+    assert_equal Mime::HTML, @response.content_type
+    assert_nil @response.charset, @response.headers.inspect
+  ensure
+    ContentTypeController.default_charset = "utf-8"
+  end
+
+  def test_default_for_rhtml
+    get :render_default_for_rhtml
+    assert_equal Mime::HTML, @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  def test_default_for_rxml
+    get :render_default_for_rxml
+    assert_equal Mime::XML, @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  def test_default_for_rjs
+    xhr :post, :render_default_for_rjs
+    assert_equal Mime::JS, @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  def test_change_for_rxml
+    get :render_change_for_rxml
+    assert_equal Mime::HTML, @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+end
+
+class AcceptBasedContentTypeTest < ActionController::TestCase
+
+  tests ContentTypeController
+
+  def setup
+    ActionController::Base.use_accept_header = true
+  end
+
+  def teardown
+    ActionController::Base.use_accept_header = false
+  end
+
+
+  def test_render_default_content_types_for_respond_to
+    @request.accept = Mime::HTML.to_s
+    get :render_default_content_types_for_respond_to
+    assert_equal Mime::HTML, @response.content_type
+
+    @request.accept = Mime::JS.to_s
+    get :render_default_content_types_for_respond_to
+    assert_equal Mime::JS, @response.content_type
+  end
+
+  def test_render_default_content_types_for_respond_to_with_template
+    @request.accept = Mime::XML.to_s
+    get :render_default_content_types_for_respond_to
+    assert_equal Mime::XML, @response.content_type
+  end
+
+  def test_render_default_content_types_for_respond_to_with_overwrite
+    @request.accept = Mime::RSS.to_s
+    get :render_default_content_types_for_respond_to
+    assert_equal Mime::XML, @response.content_type
+  end
+end

data/test/controller/cookie_test.rb

@@ -0,0 +1,134 @@
+require 'abstract_unit'
+
+class CookieTest < ActionController::TestCase
+  class TestController < ActionController::Base
+    def authenticate
+      cookies["user_name"] = "david"
+    end
+
+    def set_with_with_escapable_characters
+      cookies["that & guy"] = "foo & bar => baz"
+    end
+
+    def authenticate_for_fourteen_days
+      cookies["user_name"] = { "value" => "david", "expires" => Time.utc(2005, 10, 10,5) }
+    end
+
+    def authenticate_for_fourteen_days_with_symbols
+      cookies[:user_name] = { :value => "david", :expires => Time.utc(2005, 10, 10,5) }
+    end
+
+    def set_multiple_cookies
+      cookies["user_name"] = { "value" => "david", "expires" => Time.utc(2005, 10, 10,5) }
+      cookies["login"]     = "XJ-122"
+    end
+
+    def access_frozen_cookies
+      cookies["will"] = "work"
+    end
+
+    def logout
+      cookies.delete("user_name")
+    end
+
+    def delete_cookie_with_path
+      cookies.delete("user_name", :path => '/beaten')
+      render :text => "hello world"
+    end
+
+    def authenticate_with_http_only
+      cookies["user_name"] = { :value => "david", :httponly => true }
+    end
+
+    def rescue_action(e)
+      raise unless ActionView::MissingTemplate # No templates here, and we don't care about the output
+    end
+  end
+
+  tests TestController
+
+  def setup
+    @request.host = "www.nextangle.com"
+  end
+
+  def test_setting_cookie
+    get :authenticate
+    assert_equal ["user_name=david; path=/"], @response.headers["Set-Cookie"]
+    assert_equal({"user_name" => "david"}, @response.cookies)
+  end
+
+  def test_setting_with_escapable_characters
+    get :set_with_with_escapable_characters
+    assert_equal ["that+%26+guy=foo+%26+bar+%3D%3E+baz; path=/"], @response.headers["Set-Cookie"]
+    assert_equal({"that & guy" => "foo & bar => baz"}, @response.cookies)
+  end
+
+  def test_setting_cookie_for_fourteen_days
+    get :authenticate_for_fourteen_days
+    assert_equal ["user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT"], @response.headers["Set-Cookie"]
+    assert_equal({"user_name" => "david"}, @response.cookies)
+  end
+
+  def test_setting_cookie_for_fourteen_days_with_symbols
+    get :authenticate_for_fourteen_days_with_symbols
+    assert_equal ["user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT"], @response.headers["Set-Cookie"]
+    assert_equal({"user_name" => "david"}, @response.cookies)
+  end
+
+  def test_setting_cookie_with_http_only
+    get :authenticate_with_http_only
+    assert_equal ["user_name=david; path=/; HttpOnly"], @response.headers["Set-Cookie"]
+    assert_equal({"user_name" => "david"}, @response.cookies)
+  end
+
+  def test_multiple_cookies
+    get :set_multiple_cookies
+    assert_equal 2, @response.cookies.size
+    assert_equal "user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT", @response.headers["Set-Cookie"][0]
+    assert_equal "login=XJ-122; path=/", @response.headers["Set-Cookie"][1]
+    assert_equal({"login" => "XJ-122", "user_name" => "david"}, @response.cookies)
+  end
+
+  def test_setting_test_cookie
+    assert_nothing_raised { get :access_frozen_cookies }
+  end
+
+  def test_expiring_cookie
+    get :logout
+    assert_equal ["user_name=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT"], @response.headers["Set-Cookie"]
+    assert_equal({"user_name" => nil}, @response.cookies)
+  end
+
+  def test_cookiejar_accessor
+    @request.cookies["user_name"] = "david"
+    @controller.request = @request
+    jar = ActionController::CookieJar.new(@controller)
+    assert_equal "david", jar["user_name"]
+    assert_equal nil, jar["something_else"]
+  end
+
+  def test_cookiejar_accessor_with_array_value
+    @request.cookies["pages"] = %w{1 2 3}
+    @controller.request = @request
+    jar = ActionController::CookieJar.new(@controller)
+    assert_equal %w{1 2 3}, jar["pages"]
+  end
+
+  def test_cookiejar_delete_removes_item_and_returns_its_value
+    @request.cookies["user_name"] = "david"
+    @controller.response = @response
+    jar = ActionController::CookieJar.new(@controller)
+    assert_equal "david", jar.delete("user_name")
+  end
+
+  def test_delete_cookie_with_path
+    get :delete_cookie_with_path
+    assert_equal ["user_name=; path=/beaten; expires=Thu, 01-Jan-1970 00:00:00 GMT"], @response.headers["Set-Cookie"]
+  end
+
+  def test_cookies_persist_throughout_request
+    get :authenticate
+    cookies = @controller.send(:cookies)
+    assert_equal 'david', cookies['user_name']
+  end
+end

data/test/controller/deprecation/deprecated_base_methods_test.rb

@@ -0,0 +1,32 @@
+require 'abstract_unit'
+
+class DeprecatedBaseMethodsTest < ActionController::TestCase
+  class Target < ActionController::Base
+    def home_url(greeting)
+      "http://example.com/#{greeting}"
+    end
+
+    def raises_name_error
+      this_method_doesnt_exist
+    end
+
+    def rescue_action(e) raise e end
+  end
+
+  tests Target
+
+  def test_log_error_silences_deprecation_warnings
+    get :raises_name_error
+  rescue => e
+    assert_not_deprecated { @controller.send :log_error, e }
+  end
+
+  if defined? Test::Unit::Error
+    def test_assertion_failed_error_silences_deprecation_warnings
+      get :raises_name_error
+    rescue => e
+      error = Test::Unit::Error.new('testing ur doodz', e)
+      assert_not_deprecated { error.message }
+    end
+  end
+end

data/test/controller/dispatcher_test.rb

@@ -0,0 +1,144 @@
+require 'abstract_unit'
+
+class DispatcherTest < Test::Unit::TestCase
+  Dispatcher = ActionController::Dispatcher
+  Reloader   = ActionController::Reloader
+
+  def setup
+    ENV['REQUEST_METHOD'] = 'GET'
+    reset_dispatcher
+    Dispatcher.stubs(:require_dependency)
+  end
+
+  def teardown
+    ENV.delete 'REQUEST_METHOD'
+    reset_dispatcher
+  end
+
+  def test_clears_dependencies_after_dispatch_if_in_loading_mode
+    ActiveSupport::Dependencies.expects(:clear).once
+    # Close the response so dependencies kicks in
+    dispatch(false).last.close
+  end
+
+  def test_reloads_routes_before_dispatch_if_in_loading_mode
+    ActionController::Routing::Routes.expects(:reload).once
+    dispatch(false)
+  end
+
+  def test_leaves_dependencies_after_dispatch_if_not_in_loading_mode
+    ActionController::Routing::Routes.expects(:reload).never
+    ActiveSupport::Dependencies.expects(:clear).never
+
+    dispatch
+  end
+
+  def test_builds_middleware_stack_only_during_initialization_if_not_in_loading_mode
+    dispatcher = create_dispatcher
+    assert_not_nil dispatcher.instance_variable_get(:"@app")
+    dispatcher.instance_variable_set(:"@app", lambda { |env| })
+    dispatcher.expects(:build_middleware_stack).never
+    dispatcher.call(nil)
+    dispatcher.call(nil)
+  end
+
+  def test_rebuilds_middleware_stack_on_every_request_if_in_loading_mode
+    dispatcher = create_dispatcher(false)
+    dispatcher.instance_variable_set(:"@app", lambda { |env| })
+    dispatcher.expects(:build_middleware_stack).twice
+    dispatcher.call(nil)
+    Reloader.default_lock.unlock
+    dispatcher.call(nil)
+  end
+
+  def test_doesnt_wrap_call_in_reloader_if_not_in_loading_mode
+    Reloader.expects(:run).never
+    dispatch
+  end
+
+  def test_wraps_call_in_reloader_if_in_loading_mode
+    Reloader.expects(:run).once
+    dispatch(false)
+  end
+
+  # Stub out dispatch error logger
+  class << Dispatcher
+    def log_failsafe_exception(status, exception); end
+  end
+
+  def test_failsafe_response
+    Dispatcher.any_instance.expects(:dispatch).raises('b00m')
+    ActionController::Failsafe.any_instance.expects(:log_failsafe_exception)
+
+    response = nil
+    assert_nothing_raised do
+      response = dispatch
+    end
+    assert_equal 3, response.size
+    assert_equal 500, response[0]
+    assert_equal({"Content-Type" => "text/html"}, response[1])
+    assert_match /500 Internal Server Error/, response[2].join
+  end
+
+  def test_prepare_callbacks
+    a = b = c = nil
+    Dispatcher.to_prepare { |*args| a = b = c = 1 }
+    Dispatcher.to_prepare { |*args| b = c = 2 }
+    Dispatcher.to_prepare { |*args| c = 3 }
+
+    # Ensure to_prepare callbacks are not run when defined
+    assert_nil a || b || c
+
+    # Run callbacks
+    Dispatcher.run_prepare_callbacks
+
+    assert_equal 1, a
+    assert_equal 2, b
+    assert_equal 3, c
+
+    # Make sure they are only run once
+    a = b = c = nil
+    dispatch
+    assert_nil a || b || c
+  end
+
+  def test_to_prepare_with_identifier_replaces
+    a = b = nil
+    Dispatcher.to_prepare(:unique_id) { |*args| a = b = 1 }
+    Dispatcher.to_prepare(:unique_id) { |*args| a = 2 }
+
+    Dispatcher.run_prepare_callbacks
+    assert_equal 2, a
+    assert_equal nil, b
+  end
+
+  private
+    def dispatch(cache_classes = true)
+      ActionController::Routing::RouteSet.any_instance.stubs(:call).returns([200, {}, 'response'])
+      Dispatcher.define_dispatcher_callbacks(cache_classes)
+      Dispatcher.new.call({'rack.input' => StringIO.new('')})
+    end
+
+    def create_dispatcher(cache_classes = true)
+      Dispatcher.define_dispatcher_callbacks(cache_classes)
+      Dispatcher.new
+    end
+
+    def reset_dispatcher
+      Dispatcher.middleware = ActionController::MiddlewareStack.new do |middleware|
+        middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/middlewares.rb"))
+        middleware.instance_eval(File.read(middlewares))
+      end
+
+      # Clear callbacks as they are redefined by Dispatcher#define_dispatcher_callbacks
+      Dispatcher.instance_variable_set("@prepare_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+      Dispatcher.instance_variable_set("@before_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+      Dispatcher.instance_variable_set("@after_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+
+      Dispatcher.define_dispatcher_callbacks(true)
+    end
+
+    def assert_subclasses(howmany, klass, message = klass.subclasses.inspect)
+      assert_equal howmany, klass.subclasses.size, message
+    end
+end

data/test/controller/dom_assertions_test.rb

@@ -0,0 +1,53 @@
+require 'abstract_unit'
+
+class DomAssertionsTest < ActionView::TestCase
+  def setup
+    super
+    @html_only = '<ul><li>foo</li><li>bar</li></ul>'
+    @html_with_meaningless_whitespace = %{
+      <ul>
+        <li>\tfoo  </li>
+        <li>
+        bar
+        </li>
+      </ul>
+    }
+    @more_html_with_meaningless_whitespace = %{<ul>
+      
+      <li>foo</li>
+
+<li>bar</li></ul>}
+  end
+  
+  test "assert_dom_equal strips meaningless whitespace from expected string" do
+    assert_dom_equal @html_with_meaningless_whitespace, @html_only
+  end
+
+  test "assert_dom_equal strips meaningless whitespace from actual string" do
+    assert_dom_equal @html_only, @html_with_meaningless_whitespace
+  end
+  
+  test "assert_dom_equal strips meaningless whitespace from both expected and actual strings" do
+    assert_dom_equal @more_html_with_meaningless_whitespace, @html_with_meaningless_whitespace
+  end
+  
+  test "assert_dom_not_equal strips meaningless whitespace from expected string" do
+    assert_assertion_fails { assert_dom_not_equal @html_with_meaningless_whitespace, @html_only }
+  end
+  
+  test "assert_dom_not_equal strips meaningless whitespace from actual string" do
+    assert_assertion_fails { assert_dom_not_equal @html_only, @html_with_meaningless_whitespace }
+  end
+  
+  test "assert_dom_not_equal strips meaningless whitespace from both expected and actual strings" do
+    assert_assertion_fails do
+      assert_dom_not_equal @more_html_with_meaningless_whitespace, @html_with_meaningless_whitespace
+    end
+  end
+  
+  private
+  
+  def assert_assertion_fails
+    assert_raise(ActiveSupport::TestCase::Assertion) { yield }
+  end
+end

data/test/controller/failsafe_test.rb

@@ -0,0 +1,60 @@
+require 'abstract_unit'
+require 'stringio'
+require 'logger'
+
+class FailsafeTest < ActionController::TestCase
+  FIXTURE_PUBLIC = "#{File.dirname(__FILE__)}/../fixtures/failsafe".freeze
+  
+  def setup
+    @old_error_file_path = ActionController::Failsafe.error_file_path
+    ActionController::Failsafe.error_file_path = FIXTURE_PUBLIC
+    @app = mock
+    @log_io = StringIO.new
+    @logger = Logger.new(@log_io)
+    @failsafe = ActionController::Failsafe.new(@app)
+    @failsafe.stubs(:failsafe_logger).returns(@logger)
+  end
+  
+  def teardown
+    ActionController::Failsafe.error_file_path = @old_error_file_path
+  end
+  
+  def app_will_raise_error!
+    @app.expects(:call).then.raises(RuntimeError.new("Printer on fire"))
+  end
+  
+  def test_calls_app_and_returns_its_return_value
+    @app.expects(:call).returns([200, { "Content-Type" => "text/html" }, "ok"])
+    assert_equal [200, { "Content-Type" => "text/html" }, "ok"], @failsafe.call({})
+  end
+  
+  def test_writes_to_log_file_on_exception
+    app_will_raise_error!
+    @failsafe.call({})
+    assert_match /Printer on fire/, @log_io.string     # Logs exception message.
+    assert_match /failsafe_test\.rb/, @log_io.string   # Logs backtrace.
+  end
+  
+  def test_returns_500_internal_server_error_on_exception
+    app_will_raise_error!
+    response = @failsafe.call({})
+    assert_equal 3, response.size    # It is a valid Rack response.
+    assert_equal 500, response[0]    # Status is 500.
+  end
+  
+  def test_renders_error_page_file_with_erb
+    app_will_raise_error!
+    response = @failsafe.call({})
+    assert_equal 500, response[0]
+    assert_equal "hello my world", response[2].join
+  end
+  
+  def test_returns_a_default_message_if_erb_rendering_failed
+    app_will_raise_error!
+    @failsafe.expects(:render_template).raises(RuntimeError.new("Harddisk is crashing"))
+    response = @failsafe.call({})
+    assert_equal 500, response[0]
+    assert_match /500 Internal Server Error/, response[2].join
+    assert_match %r(please read this web application's log file), response[2].join
+  end
+end

data/test/controller/fake_controllers.rb

@@ -0,0 +1,33 @@
+class << Object; alias_method :const_available?, :const_defined?; end
+  
+class ContentController < Class.new(ActionController::Base)
+end
+class NotAController
+end
+module Admin
+  class << self; alias_method :const_available?, :const_defined?; end
+  class UserController < Class.new(ActionController::Base); end
+  class NewsFeedController < Class.new(ActionController::Base); end
+end
+
+# For speed test
+class SpeedController < ActionController::Base;  end
+class SearchController        < SpeedController; end
+class VideosController        < SpeedController; end
+class VideoFileController     < SpeedController; end
+class VideoSharesController   < SpeedController; end
+class VideoAbusesController   < SpeedController; end
+class VideoUploadsController  < SpeedController; end
+class VideoVisitsController   < SpeedController; end
+class UsersController         < SpeedController; end
+class SettingsController      < SpeedController; end
+class ChannelsController      < SpeedController; end
+class ChannelVideosController < SpeedController; end
+class SessionsController      < SpeedController; end
+class LostPasswordsController < SpeedController; end
+class PagesController         < SpeedController; end
+
+ActionController::Routing::Routes.draw do |map|
+  map.route_one 'route_one', :controller => 'elsewhere', :action => 'flash_me'
+  map.connect ':controller/:action/:id'
+end