actionpack 1.13.3 → 1.13.4

data/test/controller/addresses_render_test.rb

@@ -39,7 +39,10 @@ class AddressesTest < Test::Unit::TestCase
   end
 
   def test_list
-    get :list
+    # because pagination is deprecated
+    ActiveSupport::Deprecation.silence do
+      get :list
+    end
     assert_equal "We only need to get this far!", @response.body.chomp
   end
 end

data/test/controller/base_test.rb

@@ -88,7 +88,7 @@ class ControllerInstanceTests < Test::Unit::TestCase
   # Mocha adds methods to Object which are then included in the public_instance_methods
   # This method hides those from the controller so the above tests won't know the difference
   def hide_mocha_methods_from_controller(controller)
-    mocha_methods = [:expects, :metaclass, :mocha, :mocha_inspect, :reset_mocha, :stubba_object, :stubba_method, :stubs, :verify]
+    mocha_methods = [:expects, :metaclass, :mocha, :mocha_inspect, :reset_mocha, :stubba_object, :stubba_method, :stubs, :verify, :__is_a__, :__metaclass__]
     controller.class.send(:hide_action, *mocha_methods)
   end
   

data/test/controller/caching_test.rb

@@ -97,6 +97,7 @@ class ActionCachingTestController < ActionController::Base
   caches_action :index
 
   def index
+    sleep 0.01
     @cache_this = Time.now.to_f.to_s
     render :text => @cache_this
   end
@@ -195,7 +196,7 @@ class ActionCacheTest < Test::Unit::TestCase
   def test_xml_version_of_resource_is_treated_as_different_cache
     @mock_controller.mock_url_for = 'http://example.org/posts/'
     @mock_controller.mock_path    = '/posts/index.xml'
-    path_object = @path_class.new(@mock_controller)
+    path_object = @path_class.new(@mock_controller, {})
     assert_equal 'xml', path_object.extension
     assert_equal 'example.org/posts/index.xml', path_object.path
   end
@@ -204,7 +205,7 @@ class ActionCacheTest < Test::Unit::TestCase
     @mock_controller.mock_url_for = 'http://example.org/'
     @mock_controller.mock_path    = '/'
 
-    assert_equal 'example.org/index', @path_class.path_for(@mock_controller)
+    assert_equal 'example.org/index', @path_class.path_for(@mock_controller, {})
   end
 
   def test_file_extensions

data/test/controller/cookie_test.rb

@@ -31,6 +31,11 @@ class CookieTest < Test::Unit::TestCase
       cookies.delete("user_name")
     end
 
+    def delete_cookie_with_path
+      cookies.delete("user_name", :path => '/beaten')
+      render_text "hello world"
+    end
+
     def rescue_action(e) 
       raise unless ActionController::MissingTemplate # No templates here, and we don't care about the output 
     end
@@ -85,4 +90,10 @@ class CookieTest < Test::Unit::TestCase
     assert_equal "david", jar["user_name"]
     assert_equal nil, jar["something_else"]
   end
+
+  def test_delete_cookie_with_path
+    get :delete_cookie_with_path
+    assert_equal "/beaten", @response.headers["cookie"].first.path
+    assert_not_equal "/", @response.headers["cookie"].first.path
+  end
 end

data/test/controller/deprecation/deprecated_base_methods_test.rb

@@ -1,6 +1,12 @@
 require File.dirname(__FILE__) + '/../../abstract_unit'
 
 class DeprecatedBaseMethodsTest < Test::Unit::TestCase
+  # ActiveRecord model mock to test pagination deprecation
+  class DummyModel
+    def self.find(*args) [] end
+    def self.count(*args) 0 end
+  end
+
   class Target < ActionController::Base
     def deprecated_symbol_parameter_to_url_for
       redirect_to(url_for(:home_url, "superstars"))
@@ -18,6 +24,11 @@ class DeprecatedBaseMethodsTest < Test::Unit::TestCase
       this_method_doesnt_exist
     end
 
+    def pagination
+      paginate :dummy_models, :class_name => 'DeprecatedBaseMethodsTest::DummyModel'
+      render :nothing => true
+    end
+
     def rescue_action(e) raise e end
   end
 
@@ -27,6 +38,7 @@ class DeprecatedBaseMethodsTest < Test::Unit::TestCase
     @request    = ActionController::TestRequest.new
     @response   = ActionController::TestResponse.new
     @controller = Target.new
+    @controller.logger = Logger.new(nil) unless @controller.logger
   end
 
   def test_deprecated_symbol_parameter_to_url_for
@@ -57,4 +69,10 @@ class DeprecatedBaseMethodsTest < Test::Unit::TestCase
     error = Test::Unit::Error.new('testing ur doodz', e)
     assert_not_deprecated { error.message }
   end
+
+  def test_pagination_deprecation
+    assert_deprecated('svn://errtheblog.com/svn/plugins/classic_pagination') do
+      get :pagination
+    end
+  end
 end

data/test/controller/filter_params_test.rb

@@ -16,6 +16,7 @@ class FilterParamTest < Test::Unit::TestCase
     assert @controller.respond_to?(:filter_parameters)
     
     test_hashes = [[{},{},[]],
+    [{'foo'=>nil},{'foo'=>nil},[]],
     [{'foo'=>'bar'},{'foo'=>'bar'},[]],
     [{'foo'=>'bar'},{'foo'=>'bar'},%w'food'],
     [{'foo'=>'bar'},{'foo'=>'[FILTERED]'},%w'foo'],

data/test/controller/filters_test.rb

@@ -14,7 +14,7 @@ class FilterTest < Test::Unit::TestCase
         @ran_filter ||= []
         @ran_filter << "ensure_login"
       end
-      
+
       def clean_up
         @ran_after_filter ||= []
         @ran_after_filter << "clean_up"
@@ -62,7 +62,7 @@ class FilterTest < Test::Unit::TestCase
         render :inline => "something else"
       end
   end
-  
+
   class ConditionalFilterController < ActionController::Base
     def show
       render :inline => "ran action"
@@ -86,7 +86,7 @@ class FilterTest < Test::Unit::TestCase
         @ran_filter ||= []
         @ran_filter << "clean_up_tmp"
       end
-      
+
       def rescue_action(e) raise(e) end
   end
 
@@ -94,7 +94,7 @@ class FilterTest < Test::Unit::TestCase
     before_filter :ensure_login, :except => [ :show_without_filter, :another_action ]
   end
 
-  class OnlyConditionSymController < ConditionalFilterController 
+  class OnlyConditionSymController < ConditionalFilterController
     before_filter :ensure_login, :only => :show
   end
 
@@ -104,10 +104,10 @@ class FilterTest < Test::Unit::TestCase
 
   class BeforeAndAfterConditionController < ConditionalFilterController
     before_filter :ensure_login, :only => :show
-    after_filter  :clean_up_tmp, :only => :show 
+    after_filter  :clean_up_tmp, :only => :show
   end
-  
-  class OnlyConditionProcController < ConditionalFilterController 
+
+  class OnlyConditionProcController < ConditionalFilterController
     before_filter(:only => :show) {|c| c.assigns["ran_proc_filter"] = true }
   end
 
@@ -131,6 +131,14 @@ 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 EmptyFilterChainController < TestController
+    self.filter_chain.clear
+    def show
+      @action_executed = true
+      render :text => "yawp!"
+    end
+  end
+
   class PrependingController < TestController
     prepend_before_filter :wonderful_life
     # skip_before_filter :fire_flash
@@ -145,7 +153,7 @@ class FilterTest < Test::Unit::TestCase
   class ConditionalSkippingController < TestController
     skip_before_filter :ensure_login, :only => [ :login ]
     skip_after_filter  :clean_up,     :only => [ :login ]
-    
+
     before_filter :find_user, :only => [ :change_password ]
 
     def login
@@ -155,7 +163,7 @@ class FilterTest < Test::Unit::TestCase
     def change_password
       render :inline => "ran action"
     end
-    
+
     protected
       def find_user
         @ran_filter ||= []
@@ -166,15 +174,15 @@ class FilterTest < Test::Unit::TestCase
   class ConditionalParentOfConditionalSkippingController < ConditionalFilterController
     before_filter :conditional_in_parent, :only => [:show, :another_action]
     after_filter  :conditional_in_parent, :only => [:show, :another_action]
-    
+
     private
-      
+
       def conditional_in_parent
         @ran_filter ||= []
         @ran_filter << 'conditional_in_parent'
       end
   end
-  
+
   class ChildOfConditionalParentController < ConditionalParentOfConditionalSkippingController
     skip_before_filter :conditional_in_parent, :only => :another_action
     skip_after_filter  :conditional_in_parent, :only => :another_action
@@ -197,7 +205,7 @@ class FilterTest < Test::Unit::TestCase
       controller.assigns["was_audited"] = true
     end
   end
-  
+
   class AroundFilter
     def before(controller)
       @execution_log = "before"
@@ -209,7 +217,7 @@ class FilterTest < Test::Unit::TestCase
       controller.assigns["execution_log"] = @execution_log + " and after"
       controller.assigns["after_ran"] = true
       controller.class.execution_log << " after aroundfilter " if controller.respond_to? :execution_log
-    end    
+    end
   end
 
   class AppendedAroundFilter
@@ -219,12 +227,12 @@ class FilterTest < Test::Unit::TestCase
 
     def after(controller)
       controller.class.execution_log << " after appended aroundfilter "
-    end    
-  end  
-  
+    end
+  end
+
   class AuditController < ActionController::Base
     before_filter(AuditFilter)
-    
+
     def show
       render_text "hello"
     end
@@ -234,6 +242,14 @@ class FilterTest < Test::Unit::TestCase
     around_filter AroundFilter.new
   end
 
+  class BeforeAfterClassFilterController < PrependingController
+    begin
+      filter = AroundFilter.new
+      before_filter filter
+      after_filter filter
+    end
+  end
+
   class MixedFilterController < PrependingController
     cattr_accessor :execution_log
 
@@ -247,7 +263,7 @@ class FilterTest < Test::Unit::TestCase
     after_filter  { |c| c.class.execution_log << " after procfilter " }
     append_around_filter AppendedAroundFilter.new
   end
-  
+
   class MixedSpecializationController < ActionController::Base
     class OutOfOrder < StandardError; end
 
@@ -285,6 +301,101 @@ class FilterTest < Test::Unit::TestCase
       end
   end
 
+  class PrependingBeforeAndAfterController < ActionController::Base
+    prepend_before_filter :before_all
+    prepend_after_filter :after_all
+    before_filter :between_before_all_and_after_all
+
+    def before_all
+      @ran_filter ||= []
+      @ran_filter << 'before_all'
+    end
+
+    def after_all
+      @ran_filter ||= []
+      @ran_filter << 'after_all'
+    end
+
+    def between_before_all_and_after_all
+      @ran_filter ||= []
+      @ran_filter << 'between_before_all_and_after_all'
+    end
+    def show
+      render :text => 'hello'
+    end
+  end
+
+  class NonYieldingAroundFilterController < ActionController::Base
+
+    before_filter :filter_one
+    around_filter :non_yielding_filter
+    before_filter :filter_two
+    after_filter :filter_three
+
+    def index
+      render :inline => "index"
+    end
+
+    #make sure the controller complains
+    def rescue_action(e); raise e; end
+
+    private
+
+      def filter_one
+        @filters  ||= []
+        @filters  << "filter_one"
+      end
+
+      def filter_two
+        @filters  << "filter_two"
+      end
+
+      def non_yielding_filter
+        @filters  << "zomg it didn't yield"
+        @filter_return_value
+      end
+
+      def filter_three
+        @filters  << "filter_three"
+      end
+
+  end
+
+  def test_non_yielding_around_filters_not_returning_false_do_not_raise
+    controller = NonYieldingAroundFilterController.new
+    controller.instance_variable_set "@filter_return_value", true
+    assert_nothing_raised do
+      test_process(controller, "index")
+    end
+  end
+
+  def test_non_yielding_around_filters_returning_false_do_not_raise
+    controller = NonYieldingAroundFilterController.new
+    controller.instance_variable_set "@filter_return_value", false
+    assert_nothing_raised do
+      test_process(controller, "index")
+    end
+  end
+
+  def test_after_filters_are_not_run_if_around_filter_returns_false
+    controller = NonYieldingAroundFilterController.new
+    controller.instance_variable_set "@filter_return_value", false
+    test_process(controller, "index")
+    assert_equal ["filter_one", "zomg it didn't yield"], controller.assigns['filters']
+  end
+
+  def test_after_filters_are_not_run_if_around_filter_does_not_yield
+    controller = NonYieldingAroundFilterController.new
+    controller.instance_variable_set "@filter_return_value", true
+    test_process(controller, "index")
+    assert_equal ["filter_one", "zomg it didn't yield"], controller.assigns['filters']
+  end
+
+  def test_empty_filter_chain
+    assert_equal 0, EmptyFilterChainController.filter_chain.size
+    assert test_process(EmptyFilterChainController).template.assigns['action_executed']
+  end
+
   def test_added_filter_to_inheritance_graph
     assert_equal [ :ensure_login ], TestController.before_filters
   end
@@ -292,11 +403,11 @@ class FilterTest < Test::Unit::TestCase
   def test_base_class_in_isolation
     assert_equal [ ], ActionController::Base.before_filters
   end
-  
+
   def test_prepending_filter
     assert_equal [ :wonderful_life, :ensure_login ], PrependingController.before_filters
   end
-  
+
   def test_running_filters
     assert_equal %w( wonderful_life ensure_login ), test_process(PrependingController).template.assigns["ran_filter"]
   end
@@ -304,11 +415,11 @@ class FilterTest < Test::Unit::TestCase
   def test_running_filters_with_proc
     assert test_process(ProcController).template.assigns["ran_proc_filter"]
   end
-  
+
   def test_running_filters_with_implicit_proc
     assert test_process(ImplicitProcController).template.assigns["ran_proc_filter"]
   end
-  
+
   def test_running_filters_with_class
     assert test_process(AuditController).template.assigns["was_audited"]
   end
@@ -319,7 +430,7 @@ class FilterTest < Test::Unit::TestCase
     assert response.template.assigns["ran_class_filter"]
     assert response.template.assigns["ran_proc_filter1"]
     assert response.template.assigns["ran_proc_filter2"]
-    
+
     response = test_process(AnomolousYetValidConditionController, "show_without_filter")
     assert_equal nil, response.template.assigns["ran_filter"]
     assert !response.template.assigns["ran_class_filter"]
@@ -373,6 +484,12 @@ class FilterTest < Test::Unit::TestCase
     assert controller.template.assigns["after_ran"]
   end
 
+  def test_before_after_class_filter
+    controller = test_process(BeforeAfterClassFilterController)
+    assert controller.template.assigns["before_ran"]
+    assert controller.template.assigns["after_ran"]
+  end
+
   def test_having_properties_in_around_filter
     controller = test_process(AroundFilterController)
     assert_equal "before and after", controller.template.assigns["execution_log"]
@@ -381,10 +498,10 @@ class FilterTest < Test::Unit::TestCase
   def test_prepending_and_appending_around_filter
     controller = test_process(MixedFilterController)
     assert_equal " before aroundfilter  before procfilter  before appended aroundfilter " +
-                 " after appended aroundfilter  after aroundfilter  after procfilter ", 
+                 " after appended aroundfilter  after aroundfilter  after procfilter ",
                  MixedFilterController.execution_log
   end
-  
+
   def test_rendering_breaks_filtering_chain
     response = test_process(RenderingController)
     assert_equal "something else", response.body
@@ -412,6 +529,12 @@ class FilterTest < Test::Unit::TestCase
     end
   end
 
+  def test_running_prepended_before_and_after_filter
+    assert_equal 3, PrependingBeforeAndAfterController.filter_chain.length
+    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_conditional_skipping_of_filters
     assert_nil test_process(ConditionalSkippingController, "login").template.assigns["ran_filter"]
     assert_equal %w( ensure_login find_user ), test_process(ConditionalSkippingController, "change_password").template.assigns["ran_filter"]