actionpack 2.0.5 → 2.1.0

data/test/controller/capture_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
+require 'abstract_unit'
 
 class CaptureController < ActionController::Base
   def self.controller_name; "test"; end

data/test/controller/cgi_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
+require 'abstract_unit'
 require 'action_controller/cgi_process'
 
 class BaseCgiTest < Test::Unit::TestCase

data/test/controller/components_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
+require 'abstract_unit'
 
 class CallerController < ActionController::Base
   def calling_from_controller

data/test/controller/content_type_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
+require 'abstract_unit'
 
 class ContentTypeController < ActionController::Base
   def render_content_type_from_body
@@ -136,4 +136,4 @@ class ContentTypeTest < Test::Unit::TestCase
     get :render_default_content_types_for_respond_to
     assert_equal Mime::XML, @response.content_type
   end
-end
+end

data/test/controller/cookie_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
+require 'abstract_unit'
 
 class CookieTest < Test::Unit::TestCase
   class TestController < ActionController::Base
@@ -37,7 +37,7 @@ class CookieTest < Test::Unit::TestCase
     end
 
     def rescue_action(e) 
-      raise unless ActionController::MissingTemplate # No templates here, and we don't care about the output 
+      raise unless ActionView::MissingTemplate # No templates here, and we don't care about the output 
     end
   end
 
@@ -82,6 +82,7 @@ class CookieTest < Test::Unit::TestCase
   def test_expiring_cookie
     get :logout
     assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "", "expires" => Time.at(0)) ], @response.headers["cookie"]
+    assert_equal CGI::Cookie::new("name" => "user_name", "value" => "", "expires" => Time.at(0)).value, []
   end  
   
   def test_cookiejar_accessor
@@ -132,4 +133,14 @@ class CookieTest < Test::Unit::TestCase
     assert cookie_str !~ /secure/
     assert cookie_str !~ /HttpOnly/
   end
+
+  def test_cookies_should_not_be_split_on_ampersand_values
+    cookies = CGI::Cookie.parse('return_to=http://rubyonrails.org/search?term=api&scope=all&global=true')
+    assert_equal({"return_to" => ["http://rubyonrails.org/search?term=api&scope=all&global=true"]}, cookies)
+  end
+
+  def test_cookies_should_not_be_split_on_values_with_newlines
+    cookies = CGI::Cookie.new("name" => "val", "value" => "this\nis\na\ntest")
+    assert cookies.size == 1
+  end
 end

data/test/controller/custom_handler_test.rb

@@ -1,33 +1,36 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
+require 'abstract_unit'
 
-class CustomHandler
+class CustomHandler < ActionView::TemplateHandler
   def initialize( view )
     @view = view
   end
 
-  def render( template, local_assigns )
-    [ template,
-      local_assigns,
+  def render( template )
+    [ template.source,
+      template.locals,
       @view ]
   end
 end
 
 class CustomHandlerTest < Test::Unit::TestCase
   def setup
-    ActionView::Base.register_template_handler "foo", CustomHandler
-    ActionView::Base.register_template_handler :foo2, CustomHandler
+    ActionView::Template.register_template_handler "foo", CustomHandler
+    ActionView::Template.register_template_handler :foo2, CustomHandler
     @view = ActionView::Base.new
   end
 
   def test_custom_render
-    result = @view.render_template( "foo", "hello <%= one %>", nil, :one => "two" )
+    template = ActionView::InlineTemplate.new(@view, "hello <%= one %>", { :one => "two" }, "foo")
+
+    result = @view.render_template(template)
     assert_equal(
       [ "hello <%= one %>", { :one => "two" }, @view ],
       result )
   end
 
   def test_custom_render2
-    result = @view.render_template( "foo2", "hello <%= one %>", nil, :one => "two" )
+    template = ActionView::InlineTemplate.new(@view, "hello <%= one %>", { :one => "two" }, "foo2")
+    result = @view.render_template(template)
     assert_equal(
       [ "hello <%= one %>", { :one => "two" }, @view ],
       result )
@@ -35,7 +38,8 @@ class CustomHandlerTest < Test::Unit::TestCase
 
   def test_unhandled_extension
     # uses the ERb handler by default if the extension isn't recognized
-    result = @view.render_template( "bar", "hello <%= one %>", nil, :one => "two" )
+    template = ActionView::InlineTemplate.new(@view, "hello <%= one %>", { :one => "two" }, "bar")
+    result = @view.render_template(template)
     assert_equal "hello two", result
   end
 end

data/test/controller/deprecation/deprecated_base_methods_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../abstract_unit'
+require 'abstract_unit'
 
 class DeprecatedBaseMethodsTest < Test::Unit::TestCase
   class Target < ActionController::Base

data/test/controller/dispatcher_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../abstract_unit"
+require 'abstract_unit'
 
 uses_mocha 'dispatcher tests' do
 
@@ -11,107 +11,89 @@ class DispatcherTest < Test::Unit::TestCase
     @output = StringIO.new
     ENV['REQUEST_METHOD'] = 'GET'
 
-    Dispatcher.callbacks[:prepare].clear
+    # 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.stubs(:require_dependency)
+
     @dispatcher = Dispatcher.new(@output)
   end
 
   def teardown
-    ENV['REQUEST_METHOD'] = nil
+    ENV.delete 'REQUEST_METHOD'
   end
 
   def test_clears_dependencies_after_dispatch_if_in_loading_mode
-    Dependencies.stubs(:load?).returns(true)
-
     ActionController::Routing::Routes.expects(:reload).once
     Dependencies.expects(:clear).once
 
-    dispatch
+    dispatch(@output, false)
   end
 
   def test_leaves_dependencies_after_dispatch_if_not_in_loading_mode
-    Dependencies.stubs(:load?).returns(false)
-
     ActionController::Routing::Routes.expects(:reload).never
     Dependencies.expects(:clear).never
 
     dispatch
   end
 
+  # Stub out dispatch error logger
+  class << Dispatcher
+    def log_failsafe_exception(status, exception); end
+  end
+
   def test_failsafe_response
     CGI.expects(:new).raises('some multipart parsing failure')
-
-    ActionController::Routing::Routes.stubs(:reload)
-    Dispatcher.stubs(:log_failsafe_exception)
+    Dispatcher.expects(:log_failsafe_exception)
 
     assert_nothing_raised { dispatch }
 
     assert_equal "Status: 400 Bad Request\r\nContent-Type: text/html\r\n\r\n<html><body><h1>400 Bad Request</h1></body></html>", @output.string
   end
 
-  def test_reload_application_sets_unprepared_if_loading_dependencies
-    Dependencies.stubs(:load?).returns(false)
-    ActionController::Routing::Routes.expects(:reload).never
-    @dispatcher.unprepared = false
-    @dispatcher.send!(:reload_application)
-    assert !@dispatcher.unprepared
-
-    Dependencies.stubs(:load?).returns(true)
-    ActionController::Routing::Routes.expects(:reload).once
-    @dispatcher.send!(:reload_application)
-    assert @dispatcher.unprepared
-  end
-
-  def test_prepare_application_runs_callbacks_if_unprepared
+  def test_prepare_callbacks
     a = b = c = nil
-    Dispatcher.to_prepare { a = b = c = 1 }
-    Dispatcher.to_prepare { b = c = 2 }
-    Dispatcher.to_prepare { c = 3 }
+    Dispatcher.to_prepare { |*args| a = b = c = 1 }
+    Dispatcher.to_prepare { |*args| b = c = 2 }
+    Dispatcher.to_prepare { |*args| c = 3 }
 
-    # Skip the callbacks when already prepared.
-    @dispatcher.unprepared = false
-    @dispatcher.send! :prepare_application
+    # Ensure to_prepare callbacks are not run when defined
     assert_nil a || b || c
 
-    # Perform the callbacks when unprepared.
-    @dispatcher.unprepared = true
-    @dispatcher.send! :prepare_application
+    # Run callbacks
+    @dispatcher.send :run_callbacks, :prepare_dispatch
+
     assert_equal 1, a
     assert_equal 2, b
     assert_equal 3, c
 
-    # But when not :load, make sure they are only run once
+    # Make sure they are only run once
     a = b = c = nil
-    @dispatcher.send! :prepare_application
+    @dispatcher.send :dispatch
     assert_nil a || b || c
   end
 
   def test_to_prepare_with_identifier_replaces
     a = b = nil
-    Dispatcher.to_prepare(:unique_id) { a = b = 1 }
-    Dispatcher.to_prepare(:unique_id) { a = 2 }
+    Dispatcher.to_prepare(:unique_id) { |*args| a = b = 1 }
+    Dispatcher.to_prepare(:unique_id) { |*args| a = 2 }
 
-    @dispatcher.unprepared = true
-    @dispatcher.send! :prepare_application
+    @dispatcher.send :run_callbacks, :prepare_dispatch
     assert_equal 2, a
     assert_equal nil, b
   end
 
-  def test_to_prepare_only_runs_once_if_not_loading_dependencies
-    Dependencies.stubs(:load?).returns(false)
-    called = 0
-    Dispatcher.to_prepare(:unprepared_test) { called += 1 }
-    2.times { dispatch }
-    assert_equal 1, called
-  end
-
   private
-    def dispatch(output = @output)
+    def dispatch(output = @output, cache_classes = true)
       controller = mock
       controller.stubs(:process).returns(controller)
       controller.stubs(:out).with(output).returns('response')
 
       ActionController::Routing::Routes.stubs(:recognize).returns(controller)
 
+      Dispatcher.define_dispatcher_callbacks(cache_classes)
       Dispatcher.dispatch(nil, {}, output)
     end
 

data/test/controller/fake_controllers.rb

@@ -10,6 +10,23 @@ module Admin
   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'

data/test/controller/fake_models.rb

@@ -3,3 +3,9 @@ class Customer < Struct.new(:name, :id)
     id.to_s
   end
 end
+
+class BadCustomer < Customer
+end
+
+class GoodCustomer < Customer
+end

data/test/controller/filter_params_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
+require 'abstract_unit'
 
 class FilterParamController < ActionController::Base
 end
@@ -7,14 +7,14 @@ class FilterParamTest < Test::Unit::TestCase
   def setup
     @controller = FilterParamController.new
   end
-  
+
   def test_filter_parameters
     assert FilterParamController.respond_to?(:filter_parameter_logging)
     assert !@controller.respond_to?(:filter_parameters)
-    
+
     FilterParamController.filter_parameter_logging
     assert @controller.respond_to?(:filter_parameters)
-    
+
     test_hashes = [[{},{},[]],
     [{'foo'=>nil},{'foo'=>nil},[]],
     [{'foo'=>'bar'},{'foo'=>'bar'},[]],
@@ -24,11 +24,11 @@ class FilterParamTest < Test::Unit::TestCase
     [{'foo'=>'bar', 'baz'=>'foo'},{'foo'=>'[FILTERED]', 'baz'=>'[FILTERED]'},%w'foo baz'],
     [{'bar'=>{'foo'=>'bar','bar'=>'foo'}},{'bar'=>{'foo'=>'[FILTERED]','bar'=>'foo'}},%w'fo'],
     [{'foo'=>{'foo'=>'bar','bar'=>'foo'}},{'foo'=>'[FILTERED]'},%w'f banana']]
-    
+
     test_hashes.each do |before_filter, after_filter, filter_words|
       FilterParamController.filter_parameter_logging(*filter_words)
-      assert_equal after_filter, @controller.filter_parameters(before_filter)
-      
+      assert_equal after_filter, @controller.send!(:filter_parameters, before_filter)
+
       filter_words.push('blah')
       FilterParamController.filter_parameter_logging(*filter_words) do |key, value|
         value.reverse! if key =~ /bargain/
@@ -37,7 +37,13 @@ class FilterParamTest < Test::Unit::TestCase
       before_filter['barg'] = {'bargain'=>'gain', 'blah'=>'bar', 'bar'=>{'bargain'=>{'blah'=>'foo'}}}
       after_filter['barg'] = {'bargain'=>'niag', 'blah'=>'[FILTERED]', 'bar'=>{'bargain'=>{'blah'=>'[FILTERED]'}}}
 
-      assert_equal after_filter, @controller.filter_parameters(before_filter)
+      assert_equal after_filter, @controller.send!(:filter_parameters, before_filter)
     end
   end
+
+  def test_filter_parameters_is_protected
+    FilterParamController.filter_parameter_logging(:foo)
+    assert !FilterParamController.action_methods.include?('filter_parameters')
+    assert_raise(NoMethodError) { @controller.filter_parameters([{'password' => '[FILTERED]'}]) }
+  end
 end

data/test/controller/filters_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
+require 'abstract_unit'
 
 # FIXME: crashes Ruby 1.9
 class FilterTest < Test::Unit::TestCase
@@ -134,6 +134,11 @@ class FilterTest < Test::Unit::TestCase
     before_filter(ConditionalClassFilter, :ensure_login, Proc.new {|c| c.assigns["ran_proc_filter1"] = true }, :except => :show_without_filter) { |c| c.assigns["ran_proc_filter2"] = true}
   end
 
+  class ConditionalOptionsFilter < ConditionalFilterController
+    before_filter :ensure_login, :if => Proc.new { |c| true }
+    before_filter :clean_up_tmp, :if => Proc.new { |c| false }
+  end
+
   class EmptyFilterChainController < TestController
     self.filter_chain.clear
     def show
@@ -153,6 +158,30 @@ class FilterTest < Test::Unit::TestCase
       end
   end
 
+  class SkippingAndLimitedController < TestController
+    skip_before_filter :ensure_login
+    before_filter :ensure_login, :only => :index
+
+    def index
+      render :text => 'ok'
+    end
+    
+    def public
+    end
+  end
+  
+  class SkippingAndReorderingController < TestController
+    skip_before_filter :ensure_login
+    before_filter :find_record
+    before_filter :ensure_login
+
+    private
+      def find_record
+        @ran_filter ||= []
+        @ran_filter << "find_record"
+      end
+  end
+
   class ConditionalSkippingController < TestController
     skip_before_filter :ensure_login, :only => [ :login ]
     skip_after_filter  :clean_up,     :only => [ :login ]
@@ -466,6 +495,11 @@ class FilterTest < Test::Unit::TestCase
     assert !response.template.assigns["ran_proc_filter2"]
   end
 
+  def test_running_conditional_options
+    response = test_process(ConditionalOptionsFilter)
+    assert_equal %w( ensure_login ), response.template.assigns["ran_filter"]
+  end
+
   def test_running_collection_condition_filters
     assert_equal %w( ensure_login ), test_process(ConditionalCollectionFilterController).template.assigns["ran_filter"]
     assert_equal nil, test_process(ConditionalCollectionFilterController, "show_without_filter").template.assigns["ran_filter"]
@@ -499,13 +533,6 @@ class FilterTest < Test::Unit::TestCase
     assert_equal nil, test_process(BeforeAndAfterConditionController, "show_without_filter").template.assigns["ran_filter"]
   end
 
-  def test_bad_filter
-    bad_filter_controller = Class.new(ActionController::Base)
-    assert_raises(ActionController::ActionControllerError) do
-      bad_filter_controller.before_filter 2
-    end
-  end
-
   def test_around_filter
     controller = test_process(AroundFilterController)
     assert controller.template.assigns["before_ran"]
@@ -562,6 +589,15 @@ class FilterTest < Test::Unit::TestCase
     response = test_process(PrependingBeforeAndAfterController)
     assert_equal %w( before_all between_before_all_and_after_all after_all ), response.template.assigns["ran_filter"]
   end
+  
+  def test_skipping_and_limiting_controller
+    assert_equal %w( ensure_login ), test_process(SkippingAndLimitedController, "index").template.assigns["ran_filter"]
+    assert_nil test_process(SkippingAndLimitedController, "public").template.assigns["ran_filter"]
+  end
+
+  def test_skipping_and_reordering_controller
+    assert_equal %w( find_record ensure_login ), test_process(SkippingAndReorderingController, "index").template.assigns["ran_filter"]
+  end
 
   def test_conditional_skipping_of_filters
     assert_nil test_process(ConditionalSkippingController, "login").template.assigns["ran_filter"]
@@ -746,14 +782,6 @@ class YieldingAroundFiltersTest < Test::Unit::TestCase
     assert_equal 4, ControllerWithAllTypesOfFilters.filter_chain.size
   end
 
-  def test_wrong_filter_type
-    assert_raise ArgumentError do
-      Class.new PostsController do
-        around_filter lambda { yield }
-      end
-    end
-  end
-
   def test_base
     controller = PostsController
     assert_nothing_raised { test_process(controller,'no_raise') }