actionpack 1.4.0 → 1.5.0

data/test/controller/base_tests.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/../abstract_unit'
+require 'test/unit'
+
+# This file currently contains a few controller UTs
+# I couldn't find where the current base tests are, so I created this file.
+# If there aren't any base-specific UTs, then this file should grow as they
+# are written. If there are, or there is a better place for these, then I will
+# move them to the correct location.
+#
+# Nicholas Seckar aka. Ulysses
+
+# Provide a static version of the Controllers module instead of the auto-loading version.
+# We don't want these tests to fail when dependencies are to blame.
+module Controllers
+  module Submodule
+    class ContainedEmptyController < ActionController::Base
+    end
+    class ContainedNonEmptyController < ActionController::Base
+      def public_action
+      end
+      
+      hide_action :hidden_action
+      def hidden_action
+      end
+      
+      def another_hidden_action
+      end
+      hide_action :another_hidden_action
+    end
+    class SubclassedController < ContainedNonEmptyController
+      hide_action :public_action # Hiding it here should not affect the superclass.
+    end
+  end
+  class EmptyController < ActionController::Base
+    include ActionController::Caching
+  end
+  class NonEmptyController < ActionController::Base
+    def public_action
+    end
+    
+    hide_action :hidden_action
+    def hidden_action
+    end
+  end
+end
+
+class ControllerClassTests < Test::Unit::TestCase
+  def test_controller_path
+    assert_equal 'empty', Controllers::EmptyController.controller_path
+    assert_equal 'submodule/contained_empty', Controllers::Submodule::ContainedEmptyController.controller_path
+  end
+  def test_controller_name
+    assert_equal 'empty', Controllers::EmptyController.controller_name
+    assert_equal 'contained_empty', Controllers::Submodule::ContainedEmptyController.controller_name
+ end
+end
+
+class ControllerInstanceTests < Test::Unit::TestCase
+  def setup
+    @empty = Controllers::EmptyController.new
+    @contained = Controllers::Submodule::ContainedEmptyController.new
+    @empty_controllers = [@empty, @contained, Controllers::Submodule::SubclassedController.new]
+    
+    @non_empty_controllers = [Controllers::NonEmptyController.new,
+                              Controllers::Submodule::ContainedNonEmptyController.new]
+  
+  end
+  def test_action_methods
+    @empty_controllers.each {|c| assert_equal [], c.send(:action_methods), "#{c.class.controller_path} should be empty!"}
+    @non_empty_controllers.each {|c| assert_equal ["public_action"], c.send(:action_methods), "#{c.class.controller_path} should not be empty!"}
+  end
+end

data/test/controller/components_test.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../abstract_unit'
+
+class CallerController < ActionController::Base
+  def calling_from_controller
+    render_component(:controller => "callee", :action => "being_called")
+  end
+
+  def calling_from_controller_with_params
+    render_component(:controller => "callee", :action => "being_called", :params => { "name" => "David" })
+  end
+
+  def calling_from_controller_with_different_status_code
+    render_component(:controller => "callee", :action => "blowing_up")
+  end
+
+  def calling_from_template
+    render_template "Ring, ring: <%= render_component(:controller => 'callee', :action => 'being_called') %>"
+  end
+
+  def internal_caller
+    render_template "Are you there? <%= render_component(:action => 'internal_callee') %>"
+  end
+  
+  def internal_callee
+    render_text "Yes, ma'am"
+  end
+
+  def rescue_action(e) raise end
+end
+
+class CalleeController < ActionController::Base
+  def being_called
+    render_text "#{@params["name"] || "Lady"} of the House, speaking"
+  end
+  
+  def blowing_up
+    render_text "It's game over, man, just game over, man!", "500 Internal Server Error"
+  end
+
+  def rescue_action(e) raise end
+end
+
+class ComponentsTest < Test::Unit::TestCase
+  def setup
+    @controller = CallerController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+
+  def test_calling_from_controller
+    get :calling_from_controller
+    assert_equal "Lady of the House, speaking", @response.body
+  end
+
+  def test_calling_from_controller_with_params
+    get :calling_from_controller_with_params
+    assert_equal "David of the House, speaking", @response.body
+  end
+  
+  def test_calling_from_controller_with_different_status_code
+    get :calling_from_controller_with_different_status_code
+    assert_equal 500, @response.response_code
+  end
+
+  def test_calling_from_template
+    get :calling_from_template
+    assert_equal "Ring, ring: Lady of the House, speaking", @response.body
+  end
+  
+  def test_internal_calling
+    get :internal_caller
+    assert_equal "Are you there? Yes, ma'am", @response.body
+  end
+end

data/test/controller/cookie_test.rb

@@ -28,10 +28,6 @@ class CookieTest < Test::Unit::TestCase
       render_text "hello world"
     end
 
-    def access_frozen_cookies
-      @cookies["wont"] = "work"
-    end
-
     def rescue_action(e) raise end
   end
 
@@ -67,11 +63,6 @@ class CookieTest < Test::Unit::TestCase
     assert_equal 2, process_request.headers["cookie"].size
   end
 
-  def test_setting_cookie_on_frozen_instance_variable
-    @request.action = "access_frozen_cookies"
-    assert_raises(TypeError) { process_request }
-  end
-
   private
     def process_request
       TestController.process(@request, @response)

data/test/controller/custom_handler_test.rb

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

data/test/controller/filters_test.rb

@@ -179,6 +179,30 @@ class FilterTest < Test::Unit::TestCase
     append_around_filter AppendedAroundFilter.new
   end
   
+  class MixedSpecializationController < ActionController::Base
+    class OutOfOrder < StandardError; end
+
+    before_filter :first
+    before_filter :second, :only => :foo
+
+    def foo
+      render_text 'foo'
+    end
+
+    def bar
+      render_text 'bar'
+    end
+
+    protected
+      def first
+        @first = true
+      end
+
+      def second
+        raise OutOfOrder unless @first
+      end
+  end
+
 
   def test_added_filter_to_inheritance_graph
     assert_equal [ :fire_flash, :ensure_login ], TestController.before_filters
@@ -285,6 +309,18 @@ class FilterTest < Test::Unit::TestCase
     assert !response.template.assigns["ran_action"]
   end
 
+  def test_filters_with_mixed_specialization_run_in_order
+    assert_nothing_raised do
+      response = test_process(MixedSpecializationController, 'bar')
+      assert_equal 'bar', response.body
+    end
+
+    assert_nothing_raised do
+      response = test_process(MixedSpecializationController, 'foo')
+      assert_equal 'foo', response.body
+    end
+  end
+
   private
     def test_process(controller, action = "show")
       request = ActionController::TestRequest.new

data/test/controller/helper_test.rb

@@ -1,20 +1,30 @@
 require File.dirname(__FILE__) + '/../abstract_unit'
+$:.unshift(File.dirname(__FILE__) + '/../fixtures/helpers')
 
-class HelperTest < Test::Unit::TestCase
-  HELPER_PATHS = %w(/../fixtures/helpers)
+class TestController < ActionController::Base
+  attr_accessor :delegate_attr
+  def delegate_method() end
+  def rescue_action(e) raise end
+end
+
+module Fun
+  class GamesController < ActionController::Base
+    def render_hello_world
+      render_template "hello: <%= stratego %>"
+    end
 
-  class TestController < ActionController::Base
-    attr_accessor :delegate_attr
-    def delegate_method() end
     def rescue_action(e) raise end
   end
+end
 
-  module LocalAbcHelper
-    def a() end
-    def b() end
-    def c() end
-  end
+module LocalAbcHelper
+  def a() end
+  def b() end
+  def c() end
+end
 
+class HelperTest < Test::Unit::TestCase
+  HELPER_PATHS = %w(/../fixtures/helpers)
 
   def setup
     # Increment symbol counter.
@@ -102,6 +112,13 @@ class HelperTest < Test::Unit::TestCase
     assert template_methods.include?('delegate_attr=')
   end
 
+  def test_helper_for_nested_controller
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    @request.action = "render_hello_world"
+    
+    assert_equal "hello: Iz guuut!", Fun::GamesController.process(@request, @response).body
+  end
 
   private
     def helper_methods;   TestHelper.instance_methods      end

data/test/controller/redirect_test.rb

@@ -1,44 +1,36 @@
 require File.dirname(__FILE__) + '/../abstract_unit'
 
-class RedirectTest < Test::Unit::TestCase
-  class RedirectController < ActionController::Base
-    def simple_redirect
-      redirect_to :action => "hello_world"
-    end
-    
-    def method_redirect
-      redirect_to :dashbord_url, 1, "hello"
-    end
-    
-    def rescue_errors(e) raise e end
-    
-    protected
-      def dashbord_url(id, message)
-        url_for :action => "dashboard", :params => { "id" => id, "message" => message }
-      end
+class RedirectController < ActionController::Base
+  def simple_redirect
+    redirect_to :action => "hello_world"
+  end
+  
+  def method_redirect
+    redirect_to :dashbord_url, 1, "hello"
   end
+  
+  def rescue_errors(e) raise e end
+  
+  protected
+    def dashbord_url(id, message)
+      url_for :action => "dashboard", :params => { "id" => id, "message" => message }
+    end
+end
 
+class RedirectTest < Test::Unit::TestCase
   def setup
-    @request  = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
+    @controller = RedirectController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
   end
 
   def test_simple_redirect
-    @request.path = "/redirect/simple_redirect"
-    @request.action = "simple_redirect"
-    response = process_request
-    assert_equal "http://test.host/redirect/hello_world", response.headers["location"]
+    get :simple_redirect
+    assert_redirect_url "http://test.host/redirect/hello_world"
   end
 
   def test_redirect_with_method_reference_and_parameters
-    @request.path = "/redirect/method_redirect"
-    @request.action = "method_redirect"
-    response = process_request
-    assert_equal "http://test.host/redirect/dashboard?message=hello&id=1", response.headers["location"]
+    get :method_redirect
+    assert_redirect_url "http://test.host/redirect/dashboard/1?message=hello"
   end
-
-  private
-    def process_request
-      RedirectController.process(@request, @response)
-    end
 end

data/test/controller/render_test.rb

@@ -2,86 +2,97 @@ require File.dirname(__FILE__) + '/../abstract_unit'
 
 Customer = Struct.new("Customer", :name)
 
-class RenderTest < Test::Unit::TestCase
-  class TestController < ActionController::Base
-    layout :determine_layout
-
+module Fun
+  class GamesController < ActionController::Base
     def hello_world
     end
+  end
+end
 
-    def render_hello_world
-      render "test/hello_world"
-    end
 
-    def render_hello_world_from_variable
-      @person = "david"
-      render_text "hello #{@person}"
-    end
+class TestController < ActionController::Base
+  layout :determine_layout
 
-    def render_action_hello_world
-      render_action "hello_world"
-    end
-    
-    def render_text_hello_world
-      render_text "hello world"
-    end
-
-    def render_custom_code
-      render_text "hello world", "404 Moved"
-    end
-    
-    def render_xml_hello
-      @name = "David"
-      render "test/hello"
-    end
+  def hello_world
+  end
 
-    def greeting
-      # let's just rely on the template
-    end
+  def render_hello_world
+    render "test/hello_world"
+  end
 
-    def layout_test
-      render_action "hello_world"
-    end
-    
-    def builder_layout_test
-      render_action "hello"
-    end
+  def render_hello_world_from_variable
+    @person = "david"
+    render_text "hello #{@person}"
+  end
 
-    def partials_list
-      @customers = [ Customer.new("david"), Customer.new("mary") ]
-      render_action "list"
-    end
+  def render_action_hello_world
+    render_action "hello_world"
+  end
+  
+  def render_text_hello_world
+    render_text "hello world"
+  end
 
-    def modgreet
-    end
+  def render_custom_code
+    render_text "hello world", "404 Moved"
+  end
+  
+  def render_xml_hello
+    @name = "David"
+    render "test/hello"
+  end
 
-    def rescue_action(e) raise end
-      
-    private
-      def determine_layout
-        case action_name 
-          when "layout_test":         "layouts/standard"
-          when "builder_layout_test": "layouts/builder"
-        end
-      end
+  def greeting
+    # let's just rely on the template
   end
 
-  TestController.template_root = File.dirname(__FILE__) + "/../fixtures/"
+  def layout_test
+    render_action "hello_world"
+  end
   
-  class TestLayoutController < ActionController::Base
-    layout "layouts/standard"
-    
-    def hello_world
-    end
+  def builder_layout_test
+    render_action "hello"
+  end
+
+  def partials_list
+    @customers = [ Customer.new("david"), Customer.new("mary") ]
+    render_action "list"
+  end
+
+  def hello_in_a_string
+    @customers = [ Customer.new("david"), Customer.new("mary") ]
+    render_text "How's there? #{render_to_string("test/list")}"
+  end
+
+  def rescue_action(e) raise end
     
-    def hello_world_outside_layout
+  private
+    def determine_layout
+      case action_name 
+        when "layout_test":         "layouts/standard"
+        when "builder_layout_test": "layouts/builder"
+      end
     end
+end
 
-    def rescue_action(e)
-      raise unless ActionController::MissingTemplate === e
-    end
+TestController.template_root = File.dirname(__FILE__) + "/../fixtures/"
+Fun::GamesController.template_root = File.dirname(__FILE__) + "/../fixtures/"
+
+class TestLayoutController < ActionController::Base
+  layout "layouts/standard"
+  
+  def hello_world
+  end
+  
+  def hello_world_outside_layout
   end
 
+  def rescue_action(e)
+    raise unless ActionController::MissingTemplate === e
+  end
+end
+
+class RenderTest < Test::Unit::TestCase
   def setup
     @request    = ActionController::TestRequest.new
     @response   = ActionController::TestResponse.new
@@ -170,10 +181,14 @@ class RenderTest < Test::Unit::TestCase
     assert_equal "Hello: davidHello: mary", process_request.body
   end
 
-  def test_module_rendering
-    @request.action = "modgreet"
-    @request.parameters["module"] = "scope"
-    assert_equal "<p>Beautiful modules!</p>", process_request.body
+  def test_render_to_string
+    @request.action = "hello_in_a_string"
+    assert_equal "How's there? Hello: davidHello: mary", process_request.body
+  end
+
+  def test_nested_rendering
+    @request.action = "hello_world"
+    assert_equal "Living in a nested world", Fun::GamesController.process(@request, @response).body
   end
 
   private