actionpack 1.9.1 → 1.10.1

data/test/controller/redirect_test.rb

@@ -17,6 +17,11 @@ class RedirectController < ActionController::Base
     redirect_to :controller => 'module_test/module_redirect', :action => "hello_world"
   end
 
+  def redirect_with_assigns
+    @hello = "world"
+    redirect_to :action => "hello_world"
+  end
+
   def rescue_errors(e) raise e end
   
   protected
@@ -56,6 +61,11 @@ class RedirectTest < Test::Unit::TestCase
     get :module_redirect
     assert_redirected_to :controller => 'module_test/module_redirect', :action => 'hello_world'
   end
+
+  def test_redirect_with_assigns
+    get :redirect_with_assigns
+    assert_equal "world", assigns["hello"]
+  end
 end
 
 module ModuleTest
@@ -97,4 +107,4 @@ module ModuleTest
       assert_redirected_to :controller => 'redirect', :action => "hello_world"
     end
   end
-end
+end

data/test/controller/render_test.rb

@@ -75,6 +75,20 @@ class TestController < ActionController::Base
     render_template "Hello: <%= params[:name] %>"
   end
 
+  def accessing_local_assigns_in_inline_template
+    name = params[:local_name]
+    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
+    render :inline => "<%= 'Goodbye, ' + local_name %>",
+           :locals => { "local_name" => name }
+    ActionView::Base.local_assigns_support_string_keys = false
+  end
+
   def rescue_action(e) raise end
     
   private
@@ -140,17 +154,24 @@ class RenderTest < Test::Unit::TestCase
   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
 
     @request.action = "hello_world"
     response = process_request
     assert_nil response.template.assigns["request"]
 
     ActionController::Base.view_controller_internals = true
+    ActionController::Base.protected_variables_cache = nil
 
     @request.action = "hello_world"
     response = process_request
-    assert_kind_of ActionController::AbstractRequest, response.template.assigns["request"]
+    assert_kind_of ActionController::AbstractRequest,  response.template.assigns["request"]
+
+    ActionController::Base.view_controller_internals = view_internals_old_value
+    ActionController::Base.protected_variables_cache = nil
   end
   
   def test_render_xml
@@ -199,6 +220,18 @@ class RenderTest < Test::Unit::TestCase
     assert_equal "Hello: David", process_request.body
   end
 
+  def test_accessing_local_assigns_in_inline_template
+    @request.action = "accessing_local_assigns_in_inline_template"
+    @request.query_parameters[:local_name] = "Local David"
+    assert_equal "Goodbye, Local David", process_request.body
+  end
+  
+  def test_accessing_local_assigns_in_inline_template_with_string_keys
+    @request.action = "accessing_local_assigns_in_inline_template_with_string_keys"
+    @request.query_parameters[:local_name] = "Local David"
+    assert_equal "Goodbye, Local David", process_request.body
+  end
+
   private
     def process_request
       TestController.process(@request, @response)

data/test/controller/request_test.rb

@@ -44,6 +44,12 @@ class RequestTest < Test::Unit::TestCase
 
     @request.host = "www.rubyonrails.co.uk"
     assert_equal "rubyonrails.co.uk", @request.domain(2)
+    
+    @request.host = "192.168.1.200"
+    assert_nil @request.domain
+
+    @request.host = nil
+    assert_nil @request.domain
   end
 
   def test_subdomains
@@ -55,6 +61,12 @@ class RequestTest < Test::Unit::TestCase
 
     @request.host = "dev.www.rubyonrails.co.uk"
     assert_equal %w( dev www ), @request.subdomains(2)
+
+    @request.host = "foobar.foobar.com"
+    assert_equal %w( foobar ), @request.subdomains
+
+    @request.host = nil
+    assert_equal [], @request.subdomains
   end
   
   def test_port_string
@@ -66,8 +78,9 @@ class RequestTest < Test::Unit::TestCase
   end
   
   def test_relative_url_root
+    @request.env['SCRIPT_NAME'] = "/hieraki/dispatch.cgi"
     @request.env['SERVER_SOFTWARE'] = 'lighttpd/1.2.3'
-    assert_nil @request.relative_url_root, "relative_url_root should be disabled on lighttpd"
+    assert_equal '', @request.relative_url_root, "relative_url_root should be disabled on lighttpd"
 
     @request.env['SERVER_SOFTWARE'] = 'apache/1.2.3 some random text'
       
@@ -188,10 +201,6 @@ class RequestTest < Test::Unit::TestCase
   
 
   def test_host_with_port
-    @request.env['HTTP_HOST'] = "rubyonrails.org:8080"
-    assert_equal "rubyonrails.org:8080", @request.host_with_port
-    @request.env['HTTP_HOST'] = nil
-    
     @request.host = "rubyonrails.org"
     @request.port = 80
     assert_equal "rubyonrails.org", @request.host_with_port

data/test/controller/routing_test.rb

@@ -1,4 +1,5 @@
 require File.dirname(__FILE__) + '/../abstract_unit'
+require File.dirname(__FILE__) + '/fake_controllers'
 require 'test/unit'
 require 'stringio'
 
@@ -94,28 +95,6 @@ class CodeGeneratorTests < Test::Unit::TestCase
   end
 end 
 
-# XXX Extract to test/controller/fake_controllers.rb 
-module Object::Controllers
-  def self.const_available?(*args)
-    const_defined?(*args)
-  end
-  
-  class ContentController
-  end
-  module Admin
-    def self.const_available?(*args)
-      const_defined?(*args)
-    end
-    
-    class UserController
-    end
-
-    class NewsFeedController
-    end
-  end
-end
-
-
 class RecognitionTests < Test::Unit::TestCase
   attr_accessor :generator
   alias :g :generator
@@ -169,6 +148,19 @@ class RecognitionTests < Test::Unit::TestCase
     assert_equal({:controller => ::Controllers::ContentController, :action => 'dude'}, execute('hi/dude'))
   end 
 
+  def test_basic_dynamic_backwards
+    c = [Dynamic.new(:action), Static.new("hi")]
+    go c
+
+    assert_nil execute('')
+    assert_nil execute('boo')
+    assert_nil execute('boo/blah')
+    assert_nil execute('hi')
+    assert_equal({:action => 'index'}, execute('index/hi'))
+    assert_equal({:action => 'show'}, execute('show/hi'))
+    assert_nil execute('hi/dude')
+  end
+
   def test_dynamic_with_default
     c = [Static.new("hi"), Dynamic.new(:action, :default => 'index')]
     g.result :controller, "::Controllers::ContentController", true
@@ -186,7 +178,7 @@ class RecognitionTests < Test::Unit::TestCase
     c = [Static.new("hi"), Dynamic.new(:action, :condition => 'index')]
     g.result :controller, "::Controllers::ContentController", true
     go c
-    
+
     assert_nil execute('boo')
     assert_nil execute('boo/blah')
     assert_nil execute('hi')
@@ -194,7 +186,21 @@ class RecognitionTests < Test::Unit::TestCase
     assert_equal({:controller => ::Controllers::ContentController, :action => 'index'}, execute('hi/index'))
     assert_nil execute('hi/dude')
   end
-  
+
+  def test_dynamic_with_string_condition_backwards
+    c = [Dynamic.new(:action, :condition => 'index'), Static.new("hi")]
+    g.result :controller, "::Controllers::ContentController", true
+    go c
+
+    assert_nil execute('boo')
+    assert_nil execute('boo/blah')
+    assert_nil execute('hi')
+    assert_nil execute('dude/what/hi')
+    assert_nil execute('index/what')
+    assert_equal({:controller => ::Controllers::ContentController, :action => 'index'}, execute('index/hi'))
+    assert_nil execute('dude/hi')
+  end
+
   def test_dynamic_with_regexp_condition
     c = [Static.new("hi"), Dynamic.new(:action, :condition => /^[a-z]+$/)]
     g.result :controller, "::Controllers::ContentController", true
@@ -242,6 +248,32 @@ class RecognitionTests < Test::Unit::TestCase
     assert_equal({:controller => ::Controllers::ContentController, :action => 'download', :file => ['dude']}, execute('hi/dude'))
     assert_equal 'dude/what', execute('hi/dude/what')[:file].to_s
   end
+
+  def test_path_with_dynamic
+    c = [Dynamic.new(:action), Path.new(:file)]
+    g.result :controller, "::Controllers::ContentController", true
+
+    go c
+
+    assert_nil execute('')
+    assert_equal({:controller => ::Controllers::ContentController, :action => 'download', :file => []}, execute('download'))
+    assert_equal({:controller => ::Controllers::ContentController, :action => 'download', :file => %w(books agile_rails_dev.pdf)},
+                 execute('download/books/agile_rails_dev.pdf'))
+    assert_equal({:controller => ::Controllers::ContentController, :action => 'download', :file => ['dude']}, execute('download/dude'))
+    assert_equal 'dude/what', execute('hi/dude/what')[:file].to_s
+  end
+
+  def test_path_with_dynamic_and_default
+    c = [Dynamic.new(:action, :default => 'index'), Path.new(:file)]
+
+    go c
+
+    assert_equal({:action => 'index', :file => []}, execute(''))
+    assert_equal({:action => 'index', :file => []}, execute('index'))
+    assert_equal({:action => 'blarg', :file => []}, execute('blarg'))
+    assert_equal({:action => 'index', :file => ['content']}, execute('index/content'))
+    assert_equal({:action => 'show', :file => ['rails_dev.pdf']}, execute('show/rails_dev.pdf'))
+  end
   
   def test_controller
     c = [Static.new("hi"), Controller.new(:controller)]
@@ -259,6 +291,20 @@ class RecognitionTests < Test::Unit::TestCase
     assert_equal({:controller => ::Controllers::Admin::UserController, :action => 'hi'}, execute('hi/admin/user'))
   end
   
+  def test_controller_with_regexp
+    c = [Static.new("hi"), Controller.new(:controller, :condition => /^admin\/.+$/)]
+    g.constant_result :action, "hi"
+    
+    go c
+    
+    assert_nil execute('hi')
+    assert_nil execute('hi/x')
+    assert_nil execute('hi/content')
+    assert_equal({:controller => ::Controllers::Admin::UserController, :action => 'hi'}, execute('hi/admin/user'))
+    assert_equal({:controller => ::Controllers::Admin::NewsFeedController, :action => 'hi'}, execute('hi/admin/news_feed'))
+    assert_nil execute('hi/admin/user/foo')
+  end
+  
   def test_standard_route(time = ::RunTimeTests)
     c = [Controller.new(:controller), Dynamic.new(:action, :default => 'index'), Dynamic.new(:id, :default => nil)]
     go c
@@ -428,6 +474,17 @@ not_expired = true
     assert_equal '/hi/admin/user', execute({}, {:controller => 'admin/user'})
   end
   
+  def test_controller_with_regexp
+    c = [Static.new("hi"), Controller.new(:controller, :condition => /^admin\/.+$/)]
+    go c
+    
+    assert_nil execute({}, {})
+    assert_nil execute({:controller => 'content'}, {})
+    assert_equal '/hi/admin/user', execute({:controller => 'admin/user'}, {})
+    assert_nil execute({}, {:controller => 'content'}) 
+    assert_equal '/hi/admin/user', execute({}, {:controller => 'admin/user'})
+  end
+  
   def test_standard_route(time = ::RunTimeTests)
     c = [Controller.new(:controller), Dynamic.new(:action, :default => 'index'), Dynamic.new(:id, :default => nil)]
     go c
@@ -504,16 +561,19 @@ class RouteTests < Test::Unit::TestCase
   end
   
   def test_static
-    route 'hello/world', :known => 'known_value'
+    route 'hello/world', :known => 'known_value', :controller => 'content', :action => 'index'
     
     assert_nil rec('hello/turn')
     assert_nil rec('turn/world')
-    assert_equal({:known => 'known_value'}, rec('hello/world'))
+    assert_equal(
+      {:known => 'known_value', :controller => ::Controllers::ContentController, :action => 'index'},
+      rec('hello/world')
+    )
     
     assert_nil gen(:known => 'foo')
     assert_nil gen({})
-    assert_equal '/hello/world', gen(:known => 'known_value')
-    assert_equal '/hello/world', gen(:known => 'known_value', :extra => 'hi')
+    assert_equal '/hello/world', gen(:known => 'known_value', :controller => 'content', :action => 'index')
+    assert_equal '/hello/world', gen(:known => 'known_value', :extra => 'hi', :controller => 'content', :action => 'index')
     assert_equal [:extra], route.extra_keys(:known => 'known_value', :extra => 'hi')
   end
   
@@ -563,6 +623,7 @@ class RouteSetTests < Test::Unit::TestCase
   def setup
     @rs = ::ActionController::Routing::RouteSet.new
     @rs.draw {|m| m.connect ':controller/:action/:id' }
+    ::ActionController::Routing::NamedRoutes.clear
   end
   
   def test_default_setup
@@ -572,13 +633,13 @@ class RouteSetTests < Test::Unit::TestCase
     
     assert_equal({:controller => ::Controllers::Admin::UserController, :action => 'show', :id => '10'}.stringify_keys, rs.recognize_path(%w(admin user show 10)))
     
-    assert_equal ['/admin/user/show/10', {}], rs.generate({:controller => 'admin/user', :action => 'show', :id => 10})
+    assert_equal ['/admin/user/show/10', []], rs.generate({:controller => 'admin/user', :action => 'show', :id => 10})
     
-    assert_equal ['/admin/user/show', {}], rs.generate({:action => 'show'}, {:controller => 'admin/user', :action => 'list', :id => '10'})
-    assert_equal ['/admin/user/list/10', {}], rs.generate({}, {:controller => 'admin/user', :action => 'list', :id => '10'})
+    assert_equal ['/admin/user/show', []], rs.generate({:action => 'show'}, {:controller => 'admin/user', :action => 'list', :id => '10'})
+    assert_equal ['/admin/user/list/10', []], rs.generate({}, {:controller => 'admin/user', :action => 'list', :id => '10'})
 
-    assert_equal ['/admin/stuff', {}], rs.generate({:controller => 'stuff'}, {:controller => 'admin/user', :action => 'list', :id => '10'})
-    assert_equal ['/stuff', {}], rs.generate({:controller => '/stuff'}, {:controller => 'admin/user', :action => 'list', :id => '10'})
+    assert_equal ['/admin/stuff', []], rs.generate({:controller => 'stuff'}, {:controller => 'admin/user', :action => 'list', :id => '10'})
+    assert_equal ['/stuff', []], rs.generate({:controller => '/stuff'}, {:controller => 'admin/user', :action => 'list', :id => '10'})
   end
 
   def test_ignores_leading_slash
@@ -652,6 +713,19 @@ class RouteSetTests < Test::Unit::TestCase
     $stderr = old_stderr
   end
 
+  def test_route_with_regexp_for_controller
+    rs.draw do |map|
+      map.connect ':controller/:admintoken/:action/:id', :controller => /admin\/.+/
+      map.connect ':controller/:action/:id'
+    end
+    assert_equal({:controller => ::Controllers::Admin::UserController, :admintoken => "foo", :action => "index"}.stringify_keys,
+        rs.recognize_path(%w(admin user foo)))
+    assert_equal({:controller => ::Controllers::ContentController, :action => "foo"}.stringify_keys,
+        rs.recognize_path(%w(content foo)))
+    assert_equal ['/admin/user/foo', []], rs.generate(:controller => "admin/user", :admintoken => "foo", :action => "index")
+    assert_equal ['/content/foo',[]], rs.generate(:controller => "content", :action => "foo")
+  end
+  
   def test_basic_named_route
     rs.home '', :controller => 'content', :action => 'list' 
     x = setup_for_named_route
@@ -689,8 +763,25 @@ class RouteSetTests < Test::Unit::TestCase
     end
   end
 
+  def test_named_route_with_regexps
+    rs.draw do |map|
+      rs.article 'page/:year/:month/:day/:title', :controller => 'page', :action => 'show',
+        :year => /^\d+$/, :month => /^\d+$/, :day => /^\d+$/
+      rs.connect ':controller/:action/:id'
+    end
+    x = setup_for_named_route
+    assert_equal(
+      {:controller => '/page', :action => 'show', :title => 'hi'},
+      x.new.send(:article_url, :title => 'hi')
+    )
+    assert_equal(
+      {:controller => '/page', :action => 'show', :title => 'hi', :day => 10, :year => 2005, :month => 6},
+      x.new.send(:article_url, :title => 'hi', :day => 10, :year => 2005, :month => 6)
+    )
+  end
+
   def test_changing_controller
-    assert_equal ['/admin/stuff/show/10', {}], rs.generate(
+    assert_equal ['/admin/stuff/show/10', []], rs.generate(
       {:controller => 'stuff', :action => 'show', :id => 10},
       {:controller => 'admin/user', :action => 'index'}
     )
@@ -731,9 +822,9 @@ class RouteSetTests < Test::Unit::TestCase
       rs.connect ':controller/:action/:id'
     end
 
-    assert_equal ['/page/20', {}], rs.generate({:id => 20}, {:controller => 'pages'})
-    assert_equal ['/page/20', {}], rs.generate(:controller => 'pages', :id => 20, :action => 'show')
-    assert_equal ['/pages/boo', {}], rs.generate(:controller => 'pages', :action => 'boo')
+    assert_equal ['/page/20', []], rs.generate({:id => 20}, {:controller => 'pages'})
+    assert_equal ['/page/20', []], rs.generate(:controller => 'pages', :id => 20, :action => 'show')
+    assert_equal ['/pages/boo', []], rs.generate(:controller => 'pages', :action => 'boo')
   end
 
   def test_route_with_fixnum_default
@@ -742,10 +833,10 @@ class RouteSetTests < Test::Unit::TestCase
       rs.connect ':controller/:action/:id'
     end
 
-    assert_equal ['/page', {}], rs.generate(:controller => 'content', :action => 'show_page')
-    assert_equal ['/page', {}], rs.generate(:controller => 'content', :action => 'show_page', :id => 1)
-    assert_equal ['/page', {}], rs.generate(:controller => 'content', :action => 'show_page', :id => '1')
-    assert_equal ['/page/10', {}], rs.generate(:controller => 'content', :action => 'show_page', :id => 10)
+    assert_equal ['/page', []], rs.generate(:controller => 'content', :action => 'show_page')
+    assert_equal ['/page', []], rs.generate(:controller => 'content', :action => 'show_page', :id => 1)
+    assert_equal ['/page', []], rs.generate(:controller => 'content', :action => 'show_page', :id => '1')
+    assert_equal ['/page/10', []], rs.generate(:controller => 'content', :action => 'show_page', :id => 10)
 
     ctrl = ::Controllers::ContentController
 
@@ -755,7 +846,7 @@ class RouteSetTests < Test::Unit::TestCase
   end
 
   def test_action_expiry
-    assert_equal ['/content', {}], rs.generate({:controller => 'content'}, {:controller => 'content', :action => 'show'})
+    assert_equal ['/content', []], rs.generate({:controller => 'content'}, {:controller => 'content', :action => 'show'})
   end
 
   def test_recognition_with_uppercase_controller_name
@@ -766,6 +857,111 @@ class RouteSetTests < Test::Unit::TestCase
     assert_equal({'controller' => ::Controllers::Admin::NewsFeedController, 'action' => 'index'}, rs.recognize_path(%w(Admin NewsFeed)))
     assert_equal({'controller' => ::Controllers::Admin::NewsFeedController, 'action' => 'index'}, rs.recognize_path(%w(Admin News_Feed)))
   end
+
+  def test_both_requirement_and_optional
+    rs.draw do
+      rs.blog('test/:year', :controller => 'post', :action => 'show',
+        :defaults => { :year => nil },
+        :requirements => { :year => /\d{4}/ }
+      )
+      rs.connect ':controller/:action/:id'
+    end
+
+    assert_equal ['/test', []], rs.generate(:controller => 'post', :action => 'show')
+    assert_equal ['/test', []], rs.generate(:controller => 'post', :action => 'show', :year => nil)
+    
+    x = setup_for_named_route
+    assert_equal({:controller => '/post', :action => 'show'},
+                 x.new.send(:blog_url))
+  end
+  
+  def test_set_to_nil_forgets
+    rs.draw do
+      rs.connect 'pages/:year/:month/:day', :controller => 'content', :action => 'list_pages', :month => nil, :day => nil
+      rs.connect ':controller/:action/:id'
+    end
+    
+    assert_equal ['/pages/2005', []],
+      rs.generate(:controller => 'content', :action => 'list_pages', :year => 2005)
+    assert_equal ['/pages/2005/6', []],
+      rs.generate(:controller => 'content', :action => 'list_pages', :year => 2005, :month => 6)
+    assert_equal ['/pages/2005/6/12', []],
+      rs.generate(:controller => 'content', :action => 'list_pages', :year => 2005, :month => 6, :day => 12)
+    
+    assert_equal ['/pages/2005/6/4', []],
+      rs.generate({:day => 4}, {:controller => 'content', :action => 'list_pages', :year => '2005', :month => '6', :day => '12'})
+
+    assert_equal ['/pages/2005/6', []],
+      rs.generate({:day => nil}, {:controller => 'content', :action => 'list_pages', :year => '2005', :month => '6', :day => '12'})
+
+    assert_equal ['/pages/2005', []],
+      rs.generate({:day => nil, :month => nil}, {:controller => 'content', :action => 'list_pages', :year => '2005', :month => '6', :day => '12'})
+  end
+  
+  def test_url_with_no_action_specified
+    rs.draw do
+      rs.connect '', :controller => 'content'
+      rs.connect ':controller/:action/:id'
+    end
+    
+    assert_equal ['/', []], rs.generate(:controller => 'content', :action => 'index')
+    assert_equal ['/', []], rs.generate(:controller => 'content')
+  end
+
+  def test_named_url_with_no_action_specified
+    rs.draw do
+      rs.root '', :controller => 'content'
+      rs.connect ':controller/:action/:id'
+    end
+    
+    assert_equal ['/', []], rs.generate(:controller => 'content', :action => 'index')
+    assert_equal ['/', []], rs.generate(:controller => 'content')
+    
+    x = setup_for_named_route
+    assert_equal({:controller => '/content', :action => 'index'},
+                 x.new.send(:root_url))
+  end
+  
+  def test_url_generated_when_forgetting_action
+    [{:controller => 'content', :action => 'index'}, {:controller => 'content'}].each do |hash| 
+      rs.draw do
+        rs.root '', hash
+        rs.connect ':controller/:action/:id'
+      end
+      assert_equal ['/', []], rs.generate({:action => nil}, {:controller => 'content', :action => 'hello'})
+      assert_equal ['/', []], rs.generate({:controller => 'content'})
+      assert_equal ['/content/hi', []], rs.generate({:controller => 'content', :action => 'hi'})
+    end
+  end
+  
+  def test_named_route_method
+    rs.draw do
+      assert_raises(ArgumentError) { rs.categories 'categories', :controller => 'content', :action => 'categories' }
+      
+      rs.named_route :categories, 'categories', :controller => 'content', :action => 'categories'
+      rs.connect ':controller/:action/:id'
+    end
+
+    assert_equal ['/categories', []], rs.generate(:controller => 'content', :action => 'categories')
+    assert_equal ['/content/hi', []], rs.generate({:controller => 'content', :action => 'hi'})
+  end
+
+  def test_named_route_helper_array
+    test_named_route_method
+    assert_equal [:categories_url, :hash_for_categories_url], ::ActionController::Routing::NamedRoutes::Helpers
+  end
+
+  def test_nil_defaults
+    rs.draw do
+      rs.connect 'journal',
+        :controller => 'content',
+        :action => 'list_journal',
+        :date => nil, :user_id => nil
+      rs.connect ':controller/:action/:id'
+    end
+
+    assert_equal ['/journal', []], rs.generate(:controller => 'content', :action => 'list_journal', :date => nil, :user_id => nil)
+  end
 end
 
 end