actionpack 1.12.5 → 1.13.0

data/test/controller/render_test.rb

@@ -34,15 +34,36 @@ class TestController < ActionController::Base
   def render_action_hello_world_with_symbol
     render_action :hello_world
   end
- 
+
   def render_text_hello_world
     render_text "hello world"
   end
 
+  def render_json_hello_world
+    render_json({:hello => 'world'}.to_json)
+  end
+
+  def render_json_hello_world_with_callback
+    render_json({:hello => 'world'}.to_json, 'alert')
+  end
+
+  def render_symbol_json
+    render :json => {:hello => 'world'}.to_json
+  end
+
   def render_custom_code
     render_text "hello world", "404 Moved"
   end
-  
+
+  def render_text_appendix
+    render_text "hello world"
+    render_text ", goodbye!", "404 Not Found", true
+  end
+
+  def render_nothing_with_appendix
+    render_text "appended", nil, true
+  end
+
   def render_xml_hello
     @name = "David"
     render "test/hello"
@@ -55,11 +76,15 @@ class TestController < ActionController::Base
   def layout_test
     render_action "hello_world"
   end
-  
+
   def builder_layout_test
     render_action "hello"
   end
 
+  def builder_partial_test
+    render_action "hello_world_container"
+  end
+
   def partials_list
     @test_unchanged = 'hello'
     @customers = [ Customer.new("david"), Customer.new("mary") ]
@@ -74,7 +99,7 @@ class TestController < ActionController::Base
     @customers = [ Customer.new("david"), Customer.new("mary") ]
     render_text "How's there? #{render_to_string("test/list")}"
   end
-  
+
   def accessing_params_in_template
     render_template "Hello: <%= params[:name] %>"
   end
@@ -84,7 +109,7 @@ class TestController < ActionController::Base
     render :inline => "<%= 'Goodbye, ' + local_name %>",
            :locals => { :local_name => name }
   end
-  
+
   def accessing_local_assigns_in_inline_template_with_string_keys
     name = params[:local_name]
     ActionView::Base.local_assigns_support_string_keys = true
@@ -98,12 +123,13 @@ class TestController < ActionController::Base
   end
 
   def rescue_action(e) raise end
-    
+
   private
     def determine_layout
-      case action_name 
+      case action_name
         when "layout_test":         "layouts/standard"
         when "builder_layout_test": "layouts/builder"
+        when "render_symbol_json":  "layouts/standard"  # to make sure layouts don't interfere
       end
     end
 end
@@ -127,7 +153,7 @@ class RenderTest < Test::Unit::TestCase
   end
 
   def test_do_with_render
-    get :render_hello_world
+    assert_deprecated_render { get :render_hello_world }
     assert_template "test/hello_world"
   end
 
@@ -151,11 +177,41 @@ class RenderTest < Test::Unit::TestCase
     assert_equal "hello world", @response.body
   end
 
+  def test_do_with_render_json
+    get :render_json_hello_world
+    assert_equal '{hello: "world"}', @response.body
+    assert_equal 'application/json', @response.content_type
+  end
+
+  def test_do_with_render_json_with_callback
+    get :render_json_hello_world_with_callback
+    assert_equal 'alert({hello: "world"})', @response.body
+    assert_equal 'application/json', @response.content_type
+  end
+
+  def test_do_with_render_symbol_json
+    get :render_symbol_json
+    assert_equal '{hello: "world"}', @response.body
+    assert_equal 'application/json', @response.content_type
+  end
+
   def test_do_with_render_custom_code
     get :render_custom_code
     assert_response 404
   end
 
+  def test_do_with_render_text_appendix
+    get :render_text_appendix
+    assert_response 404
+    assert_equal 'hello world, goodbye!', @response.body
+  end
+
+  def test_do_with_render_nothing_with_appendix
+    get :render_nothing_with_appendix
+    assert_response 200
+    assert_equal 'appended', @response.body
+  end
+
   def test_attempt_to_access_object_method
     assert_raises(ActionController::UnknownAction, "No action responded to [clone]") { get :clone }
   end
@@ -164,27 +220,8 @@ class RenderTest < Test::Unit::TestCase
     assert_raises(ActionController::UnknownAction, "No action responded to [determine_layout]") { get :determine_layout }
   end
 
-  def test_access_to_request_in_view
-    view_internals_old_value = ActionController::Base.view_controller_internals
-
-    ActionController::Base.view_controller_internals = false
-    ActionController::Base.protected_variables_cache = nil
-
-    get :hello_world
-    assert_nil assigns["request"]
-
-    ActionController::Base.view_controller_internals = true
-    ActionController::Base.protected_variables_cache = nil
-
-    get :hello_world
-    assert_kind_of ActionController::AbstractRequest,  assigns["request"]
-
-    ActionController::Base.view_controller_internals = view_internals_old_value
-    ActionController::Base.protected_variables_cache = nil
-  end
-  
   def test_render_xml
-    get :render_xml_hello
+    assert_deprecated_render { get :render_xml_hello }
     assert_equal "<html>\n  <p>Hello David</p>\n<p>This is grand!</p>\n</html>\n", @response.body
   end
 
@@ -193,6 +230,11 @@ class RenderTest < Test::Unit::TestCase
     assert_equal "<p>This is grand!</p>\n", @response.body
   end
 
+  def test_render_xml_with_partial
+    get :builder_partial_test
+    assert_equal "<test>\n  <hello/>\n</test>\n", @response.body
+  end
+
   def test_layout_rendering
     get :layout_test
     assert_equal "<html>Hello world!</html>", @response.body
@@ -238,9 +280,14 @@ class RenderTest < Test::Unit::TestCase
     get :accessing_local_assigns_in_inline_template, :local_name => "Local David"
     assert_equal "Goodbye, Local David", @response.body
   end
-  
+
   def test_accessing_local_assigns_in_inline_template_with_string_keys
     get :accessing_local_assigns_in_inline_template_with_string_keys, :local_name => "Local David"
     assert_equal "Goodbye, Local David", @response.body
   end
+
+  protected
+    def assert_deprecated_render(&block)
+      assert_deprecated(/render/, &block)
+    end
 end

data/test/controller/request_test.rb

@@ -174,39 +174,55 @@ class RequestTest < Test::Unit::TestCase
     assert_equal "/path/of/some/uri?mapped=1", @request.request_uri
     assert_equal "/path/of/some/uri", @request.path
 
+    @request.set_REQUEST_URI nil
     @request.relative_url_root = nil
     @request.env['PATH_INFO'] = "/path/of/some/uri?mapped=1"
     @request.env['SCRIPT_NAME'] = "/path/dispatch.rb"
     assert_equal "/path/of/some/uri?mapped=1", @request.request_uri
     assert_equal "/of/some/uri", @request.path
 
+    @request.set_REQUEST_URI nil
     @request.relative_url_root = nil
     @request.env['PATH_INFO'] = "/path/of/some/uri"
     @request.env['SCRIPT_NAME'] = nil
     assert_equal "/path/of/some/uri", @request.request_uri
     assert_equal "/path/of/some/uri", @request.path
 
+    @request.set_REQUEST_URI nil
     @request.relative_url_root = nil
     @request.env['PATH_INFO'] = "/"
     assert_equal "/", @request.request_uri
     assert_equal "/", @request.path
 
+    @request.set_REQUEST_URI nil
     @request.relative_url_root = nil
     @request.env['PATH_INFO'] = "/?m=b"
     assert_equal "/?m=b", @request.request_uri
     assert_equal "/", @request.path
-    
+
+    @request.set_REQUEST_URI nil
     @request.relative_url_root = nil
     @request.env['PATH_INFO'] = "/"
     @request.env['SCRIPT_NAME'] = "/dispatch.cgi"
     assert_equal "/", @request.request_uri
-    assert_equal "/", @request.path    
+    assert_equal "/", @request.path
 
+    @request.set_REQUEST_URI nil
     @request.relative_url_root = nil
     @request.env['PATH_INFO'] = "/hieraki/"
     @request.env['SCRIPT_NAME'] = "/hieraki/dispatch.cgi"
     assert_equal "/hieraki/", @request.request_uri
-    assert_equal "/", @request.path    
+    assert_equal "/", @request.path
+
+    @request.set_REQUEST_URI '/hieraki/dispatch.cgi'
+    @request.relative_url_root = '/hieraki'
+    assert_equal "/dispatch.cgi", @request.path
+    @request.relative_url_root = nil
+
+    @request.set_REQUEST_URI '/hieraki/dispatch.cgi'
+    @request.relative_url_root = '/foo'
+    assert_equal "/hieraki/dispatch.cgi", @request.path
+    @request.relative_url_root = nil
 
     # This test ensures that Rails uses REQUEST_URI over PATH_INFO
     @request.relative_url_root = nil
@@ -216,7 +232,7 @@ class RequestTest < Test::Unit::TestCase
     assert_equal "/some/path", @request.request_uri
     assert_equal "/some/path", @request.path
   end
-  
+
 
   def test_host_with_port
     @request.host = "rubyonrails.org"
@@ -262,5 +278,40 @@ class RequestTest < Test::Unit::TestCase
     @request.env['HTTP_X_FORWARDED_PROTO'] = 'https'
     assert @request.ssl?
   end
+
+  def test_symbolized_request_methods
+    [:get, :post, :put, :delete].each do |method|
+      set_request_method_to method
+      assert_equal method, @request.method
+    end
+  end
+
+  def test_allow_method_hacking_on_post
+    set_request_method_to :post
+    [:get, :put, :delete].each do |method|
+      @request.instance_eval { @parameters = { :_method => method } ; @request_method = nil }
+      assert_equal method, @request.method
+    end
+  end
+
+  def test_restrict_method_hacking
+    @request.instance_eval { @parameters = { :_method => 'put' } }
+    [:get, :put, :delete].each do |method|
+      set_request_method_to method
+      assert_equal method, @request.method
+    end
+  end
   
+  def test_head_masquarading_as_get
+    set_request_method_to :head
+    assert_equal :get, @request.method
+    assert @request.get?
+    assert @request.head?
+  end
+
+  protected
+    def set_request_method_to(method)
+      @request.env['REQUEST_METHOD'] = method.to_s.upcase
+      @request.instance_eval { @request_method = nil }
+    end
 end

data/test/controller/resources_test.rb

@@ -0,0 +1,274 @@
+require File.dirname(__FILE__) + '/../abstract_unit'
+
+class ResourcesController < ActionController::Base
+  def index() render :nothing => true end
+  def rescue_action(e) raise e end
+end
+
+class ThreadsController  < ResourcesController; end
+class MessagesController < ResourcesController; end
+class CommentsController < ResourcesController; end
+
+
+class ResourcesTest < Test::Unit::TestCase
+  def test_should_arrange_actions
+    resource = ActionController::Resources::Resource.new(:messages,
+      :collection => { :rss => :get, :reorder => :post, :csv => :post },
+      :member     => { :rss => :get, :atom => :get, :upload => :post, :fix => :post },
+      :new        => { :preview => :get, :draft => :get })
+
+    assert_resource_methods [:rss],                   resource, :collection, :get
+    assert_resource_methods [:csv, :reorder],         resource, :collection, :post
+    assert_resource_methods [:edit, :rss, :atom],     resource, :member,     :get
+    assert_resource_methods [:upload, :fix],          resource, :member,     :post
+    assert_resource_methods [:new, :preview, :draft], resource, :new,        :get
+  end
+
+  def test_default_restful_routes
+    with_restful_routing :messages do
+      assert_simply_restful_for :messages
+    end
+  end
+
+  def test_multiple_default_restful_routes
+    with_restful_routing :messages, :comments do
+      assert_simply_restful_for :messages
+      assert_simply_restful_for :comments
+    end
+  end
+
+  def test_with_path_prefix
+    with_restful_routing :messages, :path_prefix => '/thread/:thread_id' do
+      assert_simply_restful_for :messages, :path_prefix => 'thread/5/', :options => { :thread_id => '5' }
+    end
+  end
+
+  def test_multile_with_path_prefix
+    with_restful_routing :messages, :comments, :path_prefix => '/thread/:thread_id' do
+      assert_simply_restful_for :messages, :path_prefix => 'thread/5/', :options => { :thread_id => '5' }
+      assert_simply_restful_for :comments, :path_prefix => 'thread/5/', :options => { :thread_id => '5' }
+    end
+  end
+  
+  def test_with_name_prefix
+    with_restful_routing :messages, :name_prefix => 'post_' do
+      assert_simply_restful_for :messages, :name_prefix => 'post_'
+    end
+  end
+
+  def test_with_collection_action
+    rss_options = {:action => 'rss'}
+    rss_path    = "/messages;rss"
+    actions = { 'a' => :put, 'b' => :post, 'c' => :delete }
+
+    with_restful_routing :messages, :collection => { :rss => :get }.merge(actions) do
+      assert_restful_routes_for :messages do |options|
+        assert_routing rss_path, options.merge(rss_options)
+
+        actions.each do |action, method|
+          assert_recognizes(options.merge(:action => action), :path => "/messages;#{action}", :method => method)
+        end
+      end
+
+      assert_restful_named_routes_for :messages do |options|
+        assert_named_route rss_path, :rss_messages_path, rss_options
+        actions.keys.each do |action|
+          assert_named_route "/messages;#{action}", "#{action}_messages_path", :action => action
+        end
+      end
+    end
+  end
+
+  def test_with_member_action
+    [:put, :post].each do |method|
+      with_restful_routing :messages, :member => { :mark => method } do
+        mark_options = {:action => 'mark', :id => '1'}
+        mark_path    = "/messages/1;mark"
+        assert_restful_routes_for :messages do |options|
+          assert_recognizes(options.merge(mark_options), :path => mark_path, :method => method)
+        end
+
+        assert_restful_named_routes_for :messages do |options|
+          assert_named_route mark_path, :mark_message_path, mark_options
+        end
+      end
+    end
+  end
+
+  def test_with_two_member_actions_with_same_method
+    [:put, :post].each do |method|
+      with_restful_routing :messages, :member => { :mark => method, :unmark => method } do
+        %w(mark unmark).each do |action|
+          action_options = {:action => action, :id => '1'}
+          action_path    = "/messages/1;#{action}"
+          assert_restful_routes_for :messages do |options|
+            assert_recognizes(options.merge(action_options), :path => action_path, :method => method)
+          end
+
+          assert_restful_named_routes_for :messages do |options|
+            assert_named_route action_path, "#{action}_message_path".to_sym, action_options
+          end
+        end
+      end
+    end
+  end
+
+
+  def test_with_new_action
+    with_restful_routing :messages, :new => { :preview => :post } do
+      preview_options = {:action => 'preview'}
+      preview_path    = "/messages/new;preview"
+      assert_restful_routes_for :messages do |options|
+        assert_recognizes(options.merge(preview_options), :path => preview_path, :method => :post)
+      end
+
+      assert_restful_named_routes_for :messages do |options|
+        assert_named_route preview_path, :preview_new_message_path, preview_options
+      end
+    end
+  end
+
+  def test_override_new_method
+    with_restful_routing :messages do
+      assert_restful_routes_for :messages do |options|
+        assert_recognizes(options.merge(:action => "new"), :path => "/messages/new", :method => :get)
+        assert_raises(ActionController::RoutingError) do
+          ActionController::Routing::Routes.recognize_path("/messages/new", :method => :post)
+        end
+      end
+    end
+
+    with_restful_routing :messages, :new => { :new => :any } do
+      assert_restful_routes_for :messages do |options|
+        assert_recognizes(options.merge(:action => "new"), :path => "/messages/new", :method => :post)
+        assert_recognizes(options.merge(:action => "new"), :path => "/messages/new", :method => :get)
+      end
+    end
+  end
+
+  def test_nested_restful_routes
+    with_routing do |set|
+      set.draw do |map|
+        map.resources :threads do |map|
+          map.resources :messages do |map|
+            map.resources :comments
+          end
+        end
+      end
+
+      assert_simply_restful_for :threads
+      assert_simply_restful_for :messages,
+        :path_prefix => 'threads/1/',
+        :options => { :thread_id => '1' }
+      assert_simply_restful_for :comments,
+        :path_prefix => 'threads/1/messages/2/',
+        :options => { :thread_id => '1', :message_id => '2' }
+    end
+  end
+
+  def test_restful_routes_dont_generate_duplicates
+    with_restful_routing :messages do
+      routes = ActionController::Routing::Routes.routes
+      routes.each do |route|
+        routes.each do |r|
+          next if route === r # skip the comparison instance
+          assert distinct_routes?(route, r), "Duplicate Route: #{route}"
+        end
+      end
+    end
+  end
+
+  protected
+    def with_restful_routing(*args)
+      with_routing do |set|
+        set.draw { |map| map.resources(*args) }
+        yield
+      end
+    end
+
+    # runs assert_restful_routes_for and assert_restful_named_routes for on the controller_name and options, without passing a block.
+    def assert_simply_restful_for(controller_name, options = {})
+      assert_restful_routes_for       controller_name, options
+      assert_restful_named_routes_for controller_name, options
+    end
+
+    def assert_restful_routes_for(controller_name, options = {})
+      (options[:options] ||= {})[:controller] = controller_name.to_s
+
+      collection_path = "/#{options[:path_prefix]}#{controller_name}"
+      member_path = "#{collection_path}/1"
+      new_path = "#{collection_path}/new"
+
+      with_options(options[:options]) do |controller|
+        controller.assert_routing collection_path,            :action => 'index'
+        controller.assert_routing "#{collection_path}.xml" ,  :action => 'index', :format => 'xml'
+        controller.assert_routing new_path,                   :action => 'new'
+        controller.assert_routing member_path,                :action => 'show', :id => '1'
+        controller.assert_routing "#{member_path};edit",      :action => 'edit', :id => '1'
+        controller.assert_routing "#{member_path}.xml",       :action => 'show', :id => '1', :format => 'xml'
+      end
+
+      assert_recognizes(
+        options[:options].merge(:action => 'create'),
+        :path => collection_path, :method => :post)
+
+      assert_recognizes(
+        options[:options].merge(:action => 'update', :id => '1'),
+        :path => member_path, :method => :put)
+
+      assert_recognizes(
+        options[:options].merge(:action => 'destroy', :id => '1'),
+        :path => member_path, :method => :delete)
+
+      yield options[:options] if block_given?
+    end
+
+    # test named routes like foo_path and foos_path map to the correct options.
+    def assert_restful_named_routes_for(controller_name, singular_name = nil, options = {})
+      if singular_name.is_a?(Hash)
+        options       = singular_name
+        singular_name = nil
+      end
+      singular_name ||= controller_name.to_s.singularize
+      (options[:options] ||= {})[:controller] = controller_name.to_s
+      @controller = "#{controller_name.to_s.camelize}Controller".constantize.new
+      @request    = ActionController::TestRequest.new
+      @response   = ActionController::TestResponse.new
+      get :index, options[:options]
+      options[:options].delete :action
+
+      full_prefix = "/#{options[:path_prefix]}#{controller_name}"
+      name_prefix = options[:name_prefix]
+
+      assert_named_route "#{full_prefix}",        "#{name_prefix}#{controller_name}_path",           options[:options]
+      assert_named_route "#{full_prefix}.xml",    "formatted_#{name_prefix}#{controller_name}_path", options[:options].merge(:format => 'xml')
+      assert_named_route "#{full_prefix}/new",    "#{name_prefix}new_#{singular_name}_path",         options[:options]
+      assert_named_route "#{full_prefix}/1",      "#{name_prefix}#{singular_name}_path",             options[:options].merge(:id => '1')
+      assert_named_route "#{full_prefix}/1;edit", "#{name_prefix}edit_#{singular_name}_path",        options[:options].merge(:id => '1')
+      assert_named_route "#{full_prefix}/1.xml",  "formatted_#{name_prefix}#{singular_name}_path",   options[:options].merge(:format => 'xml', :id => '1')
+      yield options[:options] if block_given?
+    end
+
+    def assert_named_route(expected, route, options)
+      actual =  @controller.send(route, options) rescue $!.class.name
+      assert_equal expected, actual, "Error on route: #{route}(#{options.inspect})"
+    end
+
+    def assert_resource_methods(expected, resource, action_method, method)
+      assert_equal expected.length, resource.send("#{action_method}_methods")[method].size, "#{resource.send("#{action_method}_methods")[method].inspect}"
+      expected.each do |action|
+        assert resource.send("#{action_method}_methods")[method].include?(action),
+          "#{method} not in #{action_method} methods: #{resource.send("#{action_method}_methods")[method].inspect}"
+      end
+    end
+
+    def distinct_routes? (r1, r2)
+      if r1.conditions == r2.conditions and r1.requirements == r2.requirements then
+        if r1.segments.collect(&:to_s) == r2.segments.collect(&:to_s) then
+          return false
+        end
+      end
+      true
+    end
+
+end