From b1999be5a7efd67e2602c37ed898aa8433661863 Mon Sep 17 00:00:00 2001
From: David Heinemeier Hansson <david@loudthinking.com>
Date: Tue, 15 Feb 2005 01:45:35 +0000
Subject: A hopefully more successful attempt at the Routing branch merge

git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@617 5ecf4fe2-1ee6-0310-87b1-e25e094e27de
---
 actionpack/test/controller/cookie_test.rb   |   9 -
 actionpack/test/controller/helper_test.rb   |  37 ++-
 actionpack/test/controller/render_test.rb   | 136 ++++----
 actionpack/test/controller/request_test.rb  |  22 ++
 actionpack/test/controller/routing_tests.rb | 409 +++++++++++++++++++++++
 actionpack/test/controller/url_obsolete.rb  | 487 ++++++++++++++++++++++++++++
 6 files changed, 1015 insertions(+), 85 deletions(-)
 create mode 100644 actionpack/test/controller/routing_tests.rb
 create mode 100644 actionpack/test/controller/url_obsolete.rb

(limited to 'actionpack/test/controller')

diff --git a/actionpack/test/controller/cookie_test.rb b/actionpack/test/controller/cookie_test.rb
index 3f9dafacd6..2b5b1cae9f 100644
--- a/actionpack/test/controller/cookie_test.rb
+++ b/actionpack/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)
diff --git a/actionpack/test/controller/helper_test.rb b/actionpack/test/controller/helper_test.rb
index b824e40125..0a9840f705 100644
--- a/actionpack/test/controller/helper_test.rb
+++ b/actionpack/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
diff --git a/actionpack/test/controller/render_test.rb b/actionpack/test/controller/render_test.rb
index f983960e2e..afffd15793 100644
--- a/actionpack/test/controller/render_test.rb
+++ b/actionpack/test/controller/render_test.rb
@@ -2,86 +2,91 @@ 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
 
-    def render_action_hello_world
-      render_action "hello_world"
-    end
-    
-    def render_text_hello_world
-      render_text "hello world"
-    end
+class TestController < ActionController::Base
+  layout :determine_layout
 
-    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 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/"
+
+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 +175,9 @@ 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_nested_rendering
+    @request.action = "hello_world"
+    assert_equal "Living in a nested world", Fun::GamesController.process(@request, @response).body
   end
 
   private
diff --git a/actionpack/test/controller/request_test.rb b/actionpack/test/controller/request_test.rb
index ebab660eab..c31cdd460b 100644
--- a/actionpack/test/controller/request_test.rb
+++ b/actionpack/test/controller/request_test.rb
@@ -31,6 +31,28 @@ class RequestTest < Test::Unit::TestCase
     @request.port = 8080
     assert_equal ":8080", @request.port_string
   end
+  
+  def test_request_uri
+    @request.set_REQUEST_URI "http://www.rubyonrails.org/path/of/some/uri?mapped=1"
+    assert_equal "/path/of/some/uri?mapped=1", @request.request_uri
+    assert_equal "/path/of/some/uri", @request.path
+    
+    @request.set_REQUEST_URI "http://www.rubyonrails.org/path/of/some/uri"
+    assert_equal "/path/of/some/uri", @request.request_uri
+    assert_equal "/path/of/some/uri", @request.path
+
+    @request.set_REQUEST_URI "/path/of/some/uri"
+    assert_equal "/path/of/some/uri", @request.request_uri
+    assert_equal "/path/of/some/uri", @request.path
+
+    @request.set_REQUEST_URI "/"
+    assert_equal "/", @request.request_uri
+    assert_equal "/", @request.path
+
+    @request.set_REQUEST_URI "/?m=b"
+    assert_equal "/?m=b", @request.request_uri
+    assert_equal "/", @request.path
+  end
 
   def test_host_with_port
     @request.env['HTTP_HOST'] = "rubyonrails.org:8080"
diff --git a/actionpack/test/controller/routing_tests.rb b/actionpack/test/controller/routing_tests.rb
new file mode 100644
index 0000000000..cdc9c4e53c
--- /dev/null
+++ b/actionpack/test/controller/routing_tests.rb
@@ -0,0 +1,409 @@
+# Code Generated by ZenTest v. 2.3.0
+# Couldn't find class for name Routing
+#                 classname: asrt / meth =  ratio%
+# ActionController::Routing::RouteSet:    0 /   16 =   0.00%
+# ActionController::Routing::RailsRoute:    0 /    4 =   0.00%
+# ActionController::Routing::Route:    0 /    8 =   0.00%
+
+RAILS_ROOT = ""
+require File.dirname(__FILE__) + '/../abstract_unit'
+require 'test/unit'
+require 'cgi'
+
+class FakeController
+  attr_reader :controller_path
+  attr_reader :name
+  def initialize(name, controller_path)
+    @name = name
+    @controller_path = controller_path
+  end
+  def kind_of?(x)
+    x === Class || x == FakeController
+  end
+end
+
+module Controllers
+  module Admin
+    UserController = FakeController.new 'Admin::UserController', 'admin/user'
+    AccessController = FakeController.new 'Admin::AccessController', 'admin/access'
+  end
+  module Editing
+    PageController = FakeController.new 'Editing::PageController', 'editing/page'
+    ImageController = FakeController.new 'Editing::ImageController', 'editing/image'
+  end
+  module User
+    NewsController = FakeController.new 'User::NewsController', 'user/news'
+    PaymentController = FakeController.new 'User::PaymentController', 'user/payment'
+  end
+  ContentController = FakeController.new 'ContentController', 'content'
+  ResourceController = FakeController.new 'ResourceController', 'resource'
+end
+
+# Extend the modules with the required methods...
+[Controllers, Controllers::Admin, Controllers::Editing, Controllers::User].each do |mod|
+  mod.instance_eval('alias :const_available? :const_defined?')
+  mod.constants.each {|k| Object.const_set(k, mod.const_get(k))} # export the modules & controller classes.
+end
+  
+
+class RouteTests < Test::Unit::TestCase
+  def route(*args)
+    return @route if @route && (args.empty? || @args == args)
+    @args = args
+    @route = ActionController::Routing::Route.new(*args)
+    return @route
+  end
+
+  def setup
+    self.route '/:controller/:action/:id'
+    @defaults = {:controller => 'content', :action => 'show', :id => '314'}
+  end
+  
+  # Don't put a leading / on the url.
+  # Make sure the controller is one from the above fake Controllers module.
+  def verify_recognize(url, expected_options, reason='')
+    url = url.split('/') if url.kind_of? String
+    reason = ": #{reason}" unless reason.empty?
+    controller_class, options = @route.recognize(url)
+    assert_not_equal nil, controller_class, "#{@route.inspect} didn't recognize #{url}#{reason}\n   #{options}"
+    assert_equal expected_options, options, "#{@route.inspect} produced wrong options for #{url}#{reason}"
+  end
+  
+  # The expected url should not have a leading /
+  # You can use @defaults if you want a set of plausible defaults
+  def verify_generate(expected_url, expected_extras, options, defaults, reason='')
+    reason = "#{reason}: " unless reason.empty?
+    components, extras = @route.generate(options, defaults)
+    assert_not_equal nil, components, "#{reason}#{@route.inspect} didn't generate for \n   options = #{options.inspect}\n   defaults = #{defaults.inspect}\n   #{extras}"
+    assert_equal expected_extras, extras, "#{reason} #{@route.inspect}.generate: incorrect extra's"
+    assert_equal expected_url, components.join('/'), "#{reason} #{@route.inspect}.generate: incorrect url"
+  end
+  
+  def test_recognize_default_unnested_with_action_and_id
+    verify_recognize('content/action/id', {:controller => 'content', :action => 'action', :id => 'id'})
+    verify_recognize('content/show/10', {:controller => 'content', :action => 'show', :id => '10'})
+  end
+  def test_generate_default_unnested_with_action_and_id_no_extras
+    verify_generate('content/action/id', {}, {:controller => 'content', :action => 'action', :id => 'id'}, @defaults)
+    verify_generate('content/show/10', {}, {:controller => 'content', :action => 'show', :id => '10'}, @defaults)
+  end
+  def test_generate_default_unnested_with_action_and_id
+    verify_generate('content/action/id', {:a => 'a'}, {:controller => 'content', :action => 'action', :id => 'id', :a => 'a'}, @defaults)
+    verify_generate('content/show/10', {:a => 'a'}, {:controller => 'content', :action => 'show', :id => '10', :a => 'a'}, @defaults)
+  end
+  
+  # Note that we can't put tests here for proper relative controller handline
+  # because that is handled by RouteSet.
+  def test_recognize_default_nested_with_action_and_id
+    verify_recognize('admin/user/action/id', {:controller => 'admin/user', :action => 'action', :id => 'id'})
+    verify_recognize('admin/user/show/10', {:controller => 'admin/user', :action => 'show', :id => '10'})
+  end
+  def test_generate_default_nested_with_action_and_id_no_extras
+    verify_generate('admin/user/action/id', {}, {:controller => 'admin/user', :action => 'action', :id => 'id'}, @defaults)
+    verify_generate('admin/user/show/10', {}, {:controller => 'admin/user', :action => 'show', :id => '10'}, @defaults)
+  end
+  def test_generate_default_nested_with_action_and_id_relative_to_root
+    verify_generate('admin/user/action/id', {:a => 'a'}, {:controller => 'admin/user', :action => 'action', :id => 'id', :a => 'a'}, @defaults)
+    verify_generate('admin/user/show/10', {:a => 'a'}, {:controller => 'admin/user', :action => 'show', :id => '10', :a => 'a'}, @defaults)
+  end
+  
+  def test_recognize_default_nested_with_action
+    verify_recognize('admin/user/action', {:controller => 'admin/user', :action => 'action'})
+    verify_recognize('admin/user/show', {:controller => 'admin/user', :action => 'show'})
+  end
+  def test_generate_default_nested_with_action_no_extras
+    verify_generate('admin/user/action', {}, {:controller => 'admin/user', :action => 'action'}, @defaults)
+    verify_generate('admin/user/show', {}, {:controller => 'admin/user', :action => 'show'}, @defaults)
+  end
+  def test_generate_default_nested_with_action
+    verify_generate('admin/user/action', {:a => 'a'}, {:controller => 'admin/user', :action => 'action', :a => 'a'}, @defaults)
+    verify_generate('admin/user/show', {:a => 'a'}, {:controller => 'admin/user', :action => 'show', :a => 'a'}, @defaults)
+  end
+
+  def test_recognize_default_nested_with_id_and_index
+    verify_recognize('admin/user/index/hello', {:controller => 'admin/user', :id => 'hello', :action => 'index'})
+    verify_recognize('admin/user/index/10', {:controller => 'admin/user', :id => "10", :action => 'index'})
+  end
+  def test_generate_default_nested_with_id_no_extras
+    verify_generate('admin/user/index/hello', {}, {:controller => 'admin/user', :id => 'hello'}, @defaults)
+    verify_generate('admin/user/index/10', {}, {:controller => 'admin/user', :id => 10}, @defaults)
+  end
+  def test_generate_default_nested_with_id
+    verify_generate('admin/user/index/hello', {:a => 'a'}, {:controller => 'admin/user', :id => 'hello', :a => 'a'}, @defaults)
+    verify_generate('admin/user/index/10', {:a => 'a'}, {:controller => 'admin/user', :id => 10, :a => 'a'}, @defaults)
+  end
+  
+  def test_recognize_default_nested
+    verify_recognize('admin/user', {:controller => 'admin/user', :action => 'index'})
+    verify_recognize('admin/user', {:controller => 'admin/user', :action => 'index'})
+  end
+  def test_generate_default_nested_no_extras
+    verify_generate('admin/user/', {}, {:controller => 'admin/user'}, @defaults)
+    verify_generate('admin/user/', {}, {:controller => 'admin/user'}, @defaults)
+  end
+  def test_generate_default_nested
+    verify_generate('admin/user/', {:a => 'a'}, {:controller => 'admin/user', :a => 'a'}, @defaults)
+    verify_generate('admin/user/', {:a => 'a'}, {:controller => 'admin/user', :a => 'a'}, @defaults)
+  end
+  
+  # Test generate with a default controller set.
+  def test_generate_default_controller
+    route '/:controller/:action/:id', :action => 'index', :id => nil, :controller => 'content'
+    @defaults[:controller] = 'resource'
+    
+    verify_generate('', {}, {:controller => 'content'}, @defaults)
+    verify_generate('', {}, {:controller => 'content', :action => 'index'}, @defaults)
+    verify_generate('content/not-index', {}, {:controller => 'content', :action => 'not-index'}, @defaults)
+    verify_generate('content/index/10', {}, {:controller => 'content', :id => 10}, @defaults)
+    verify_generate('content/index/hi', {}, {:controller => 'content', :action => 'index', :id => 'hi'}, @defaults)
+    verify_generate('', {:a => 'a'}, {:controller => 'content', :a => 'a'}, @defaults)
+    verify_generate('', {:a => 'a'}, {:controller => 'content', :a => 'a'}, @defaults)
+    
+    # Call some other generator tests
+    test_generate_default_unnested_with_action_and_id
+    test_generate_default_nested_with_action_and_id_no_extras
+    test_generate_default_nested_with_id
+    test_generate_default_nested_with_id_no_extras
+  end
+
+  # Test generate with a default controller set.
+  def test_generate_default_controller
+    route '/:controller/:action/:id', :action => 'index', :id => nil, :controller => 'content'
+    @defaults[:controller] = 'resource'
+    verify_recognize('', {:controller => 'content', :action => 'index'})
+    verify_recognize('content', {:controller => 'content', :action => 'index'})
+    verify_recognize('content/index', {:controller => 'content', :action => 'index'})
+    verify_recognize('content/index/10', {:controller => 'content', :action => 'index', :id => '10'})
+  end
+    # Make sure generation & recognition don't happen in some cases:
+  def test_no_generate_on_no_options
+    assert_equal nil, @route.generate({}, {})[0]
+  end
+  def test_requirements
+    route 'some_static/route', :controller => 'content'
+    assert_equal nil, @route.generate({}, {})[0]
+    assert_equal nil, @route.generate({:controller => "dog"}, {})[0]
+    assert_equal nil, @route.recognize([])[0]
+    assert_equal nil, @route.recognize(%w{some_static route with more than expected})[0]
+  end
+
+  def test_basecamp
+    route 'clients/', :controller => 'content'
+    verify_generate('clients', {}, {:controller => 'content'}, {}) # Would like to have clients/
+    verify_generate('clients', {}, {:controller => 'content'}, @defaults)
+  end
+
+  def test_basecamp2
+    route 'clients/:client_name/:project_name/', :controller => 'content', :action => 'start_page_redirect'
+    verify_recognize('clients/projects/2', {:controller => 'content', :client_name => 'projects', :project_name => '2', :action => 'start_page_redirect'})
+  end
+  
+  def test_xal_style_dates
+    route 'articles/:category/:year/:month/:day', :controller => 'content', :action => 'list_articles', :category => 'all', :year => nil, :month => nil, :day =>nil
+    verify_recognize('articles', {:controller => 'content', :action => 'list_articles', :category => 'all'})
+    verify_recognize('articles/porn', {:controller => 'content', :action => 'list_articles', :category => 'porn'})
+    verify_recognize('articles/news/2005/08', {:controller => 'content', :action => 'list_articles', :category => 'news', :year => '2005', :month => '08'})
+    verify_recognize('articles/news/2005/08/04', {:controller => 'content', :action => 'list_articles', :category => 'news', :year => '2005', :month => '08', :day => '04'})
+    assert_equal nil, @route.recognize(%w{articles too many components are here})[0]
+    assert_equal nil, @route.recognize('')[0]
+    
+    verify_generate('articles', {}, {:controller => 'content', :action => 'list_articles'}, @defaults)
+    verify_generate('articles', {}, {:controller => 'content', :action => 'list_articles', :category => 'all'}, @defaults)
+    verify_generate('articles/news', {}, {:controller => 'content', :action => 'list_articles', :category => 'news'}, @defaults)
+    verify_generate('articles/news/2005', {}, {:controller => 'content', :action => 'list_articles', :category => 'news', :year => '2005'}, @defaults)
+    verify_generate('articles/news/2005/05', {}, {:controller => 'content', :action => 'list_articles', :category => 'news', :year => '2005', :month => '05'}, @defaults)
+    verify_generate('articles/news/2005/05/16', {}, {:controller => 'content', :action => 'list_articles', :category => 'news', :year => '2005', :month => '05', :day => '16'}, @defaults)
+
+    assert_equal nil, @route.generate({:controller => 'content', :action => 'list_articles', :day => '2'}, @defaults)[0]
+    # The above case should fail because a nil value cannot be present in a path.
+    # In other words, since :day is given, :month and :year must be given too.
+  end
+  
+  
+  def test_no_controller
+    route 'some/:special/:route', :controller => 'a/missing/controller', :action => 'anything'
+    assert_raises(ActionController::RoutingError, "Should raise due to nonexistant controller") {@route.recognize(%w{some matching path})}
+  end
+  def test_bad_controller_path
+    assert_equal nil, @route.recognize(%w{no such controller fake_action id})[0]
+  end
+  def test_too_short_path
+    assert_equal nil, @route.recognize([])[0]
+    route 'some/static/route', :controller => 'content', :action => 'show'
+    assert_equal nil, route.recognize([])[0]
+  end
+  def test_too_long_path
+    assert_equal nil, @route.recognize(%w{content action id some extra components})[0]
+  end
+  def test_incorrect_static_component
+    route 'some/static/route', :controller => 'content', :action => 'show'
+    assert_equal nil, route.recognize(%w{an non_matching path})[0]
+  end
+  def test_no_controller_defined
+    route 'some/:path/:without/a/controller'
+    assert_equal nil, route.recognize(%w{some matching path a controller})[0]
+  end
+  
+  def test_mismatching_requirements
+    route 'some/path', :controller => 'content', :action => 'fish'
+    assert_equal nil, route.generate({:controller => 'admin/user', :action => 'list'})[0]
+    assert_equal nil, route.generate({:controller => 'content', :action => 'list'})[0]
+    assert_equal nil, route.generate({:controller => 'admin/user', :action => 'fish'})[0]
+  end
+  
+  def test_missing_value_for_generate
+    assert_equal nil, route.generate({})[0] # :controller is missing
+  end
+  def test_nils_inside_generated_path
+    route 'show/:year/:month/:day', :month => nil, :day => nil, :controller => 'content', :action => 'by_date'
+    assert_equal nil, route.generate({:year => 2005, :day => 10})[0]
+  end
+  
+  def test_expand_controller_path_non_nested_no_leftover
+    controller, leftovers = @route.send :eat_path_to_controller, %w{content}
+    assert_equal Controllers::ContentController, controller
+    assert_equal [], leftovers
+  end
+  def test_expand_controller_path_non_nested_with_leftover
+    controller, leftovers = @route.send :eat_path_to_controller, %w{content action id}
+    assert_equal Controllers::ContentController, controller
+    assert_equal %w{action id}, leftovers
+  end
+  def test_expand_controller_path_nested_no_leftover
+    controller, leftovers = @route.send :eat_path_to_controller, %w{admin user}
+    assert_equal Controllers::Admin::UserController, controller
+    assert_equal [], leftovers
+  end
+  def test_expand_controller_path_nested_no_leftover
+    controller, leftovers = @route.send :eat_path_to_controller, %w{admin user action id}
+    assert_equal Controllers::Admin::UserController, controller
+    assert_equal %w{action id}, leftovers
+  end
+end
+
+class RouteSetTests < Test::Unit::TestCase
+  def setup
+    @set = ActionController::Routing::RouteSet.new
+    @rails_route = ActionController::Routing::Route.new '/:controller/:action/:id', :action => 'index', :id => nil
+    @request = ActionController::TestRequest.new({}, {}, nil)
+  end
+  def test_emptyness
+    assert_equal true, @set.empty?, "New RouteSets should respond to empty? with true."
+    @set.each { flunk "New RouteSets should be empty." }
+  end
+  def test_add_illegal_route
+    assert_raises(TypeError) {@set.add_route "I'm not actually a route."}
+  end
+  def test_add_normal_route
+    @set.add_route @rails_route
+    seen = false
+    @set.each do |route|
+      assert_equal @rails_route, route
+      flunk("Each should have yielded only a single route!") if seen
+      seen = true
+    end
+  end
+  
+  def test_expand_controller_path_non_relative
+    defaults = {:controller => 'admin/user', :action => 'list'}
+    options = {:controller => '/content'}
+    @set.expand_controller_path!(options, defaults)
+    assert_equal({:controller => 'content'}, options)
+  end
+  def test_expand_controller_path_relative_to_nested
+    defaults = {:controller => 'admin/user', :action => 'list'}
+    options = {:controller => 'access'}
+    @set.expand_controller_path!(options, defaults)
+    assert_equal({:controller => 'admin/access'}, options)
+  end
+  def test_expand_controller_path_relative_to_root
+    defaults = {:controller => 'content', :action => 'list'}
+    options = {:controller => 'resource'}
+    @set.expand_controller_path!(options, defaults)
+    assert_equal({:controller => 'resource'}, options)
+  end
+  def test_expand_controller_path_into_module
+    defaults = {:controller => 'content', :action => 'list'}
+    options = {:controller => 'admin/user'}
+    @set.expand_controller_path!(options, defaults)
+    assert_equal({:controller => 'admin/user'}, options)
+  end
+  def test_expand_controller_path_switch_module_with_absolute
+    defaults = {:controller => 'user/news', :action => 'list'}
+    options = {:controller => '/admin/user'}
+    @set.expand_controller_path!(options, defaults)
+    assert_equal({:controller => 'admin/user'}, options)
+  end
+  def test_expand_controller_no_default
+    options = {:controller => 'content'}
+    @set.expand_controller_path!(options, {})
+    assert_equal({:controller => 'content'}, options)
+  end
+  
+  # Don't put a leading / on the url.
+  # Make sure the controller is one from the above fake Controllers module.
+  def verify_recognize(expected_controller, expected_path_parameters=nil, path=nil)
+    @set.add_route(@rails_route) if @set.empty?
+    @request.path = path if path
+    controller = @set.recognize!(@request)
+    assert_equal expected_controller, controller
+    assert_equal expected_path_parameters, @request.path_parameters if expected_path_parameters
+  end
+  
+  # The expected url should not have a leading /
+  # You can use @defaults if you want a set of plausible defaults
+  def verify_generate(expected_url, options, expected_extras={})
+    @set.add_route(@rails_route) if @set.empty?
+    components, extras = @set.generate(options, @request)
+    assert_equal expected_extras, extras, "#incorrect extra's"
+    assert_equal expected_url, components.join('/'), "incorrect url"
+  end
+  def typical_request
+    @request.path_parameters = {:controller => 'content', :action => 'show', :id => '10'}
+  end
+  def typical_nested_request
+    @request.path_parameters = {:controller => 'admin/user', :action => 'grant', :id => '02seckar'}
+  end
+  
+  def test_generate_typical_controller_action_path
+    typical_request
+    verify_generate('content/list', {:controller => 'content', :action => 'list'})
+  end
+  def test_generate_typical_controller_index_path_explicit_index
+    typical_request
+    verify_generate('content/', {:controller => 'content', :action => 'index'})
+  end
+  def test_generate_typical_controller_index_path_explicit_index
+    typical_request
+    verify_generate('content/', {:controller => 'content', :action => 'index'})
+  end
+  def test_generate_typical_controller_index_path_implicit_index
+    typical_request
+    @request.path_parameters[:controller] = 'resource'
+    verify_generate('content/', {:controller => 'content'})
+  end
+  
+  def test_generate_no_perfect_route
+    typical_request
+    verify_generate('admin/user/show/43seckar', {:controller => 'admin/user', :action => 'show', :id => '43seckar', :likes_fishing => 'fuzzy(0.3)'}, {:likes_fishing => 'fuzzy(0.3)'})
+  end
+  
+  def test_generate_no_match
+    @set.add_route(@rails_route)
+    @request.path_parameters = {}
+    assert_raises(ActionController::RoutingError) {@set.generate({}, @request)}
+  end
+  
+  
+  def test_encoded_strings
+    verify_recognize(Controllers::Admin::UserController, {:controller => 'admin/user', :action => 'info', :id => "Nicholas Seckar"}, path='/admin/user/info/Nicholas%20Seckar')
+  end
+end
+
+#require '../assertions/action_pack_assertions.rb'
+class AssertionRoutingTests < Test::Unit::TestCase
+  def test_assert_routing
+    ActionController::Routing::Routes.reload rescue nil
+    assert_routing('content/', {:controller => 'content', :action => 'index'})
+  end
+end
diff --git a/actionpack/test/controller/url_obsolete.rb b/actionpack/test/controller/url_obsolete.rb
new file mode 100644
index 0000000000..4b6544dbf7
--- /dev/null
+++ b/actionpack/test/controller/url_obsolete.rb
@@ -0,0 +1,487 @@
+require File.dirname(__FILE__) + '/../abstract_unit'
+require 'action_controller/url_rewriter'
+
+MockRequest = Struct.new("MockRequest", :protocol, :host, :port, :path, :parameters, :path_parameters)
+class MockRequest
+  def host_with_port
+    if (protocol == "http://" && port == 80) || (protocol == "https://" && port == 443)
+      host
+    else
+      host + ":#{port}"
+    end
+  end
+end
+
+class UrlMockFactory
+  def self.create(path, parameters)
+    ActionController::UrlRewriter.new(
+      MockRequest.new("http://", "example.com", 80, path, parameters), 
+      parameters
+    )
+  end
+end
+
+# old-style support for .new
+module ActionController
+  class UrlRewriter
+    def self.old_new(request, controller, action)
+      request.parameters[:controller] = controller
+      request.parameters[:action] = action
+      return new(request, request.parameters)
+    end
+  end
+end
+class UrlTest < Test::Unit::TestCase
+  def setup
+    @library_url = ActionController::UrlRewriter.old_new(MockRequest.new(
+      "http://",
+      "www.singlefile.com", 
+      80,
+      "/library/books/ISBN/0743536703/show",
+      { "type" => "ISBN", "code" => "0743536703" }
+    ), "books", "show")
+
+    @library_url_using_module = ActionController::UrlRewriter.old_new(MockRequest.new(
+      "http://",
+      "www.singlefile.com", 
+      80,
+      "/library/books/ISBN/0743536703/show",
+      { "type" => "ISBN", "code" => "0743536703", "module" => "library" }
+    ), "books", "show")
+
+    @library_url_on_index = ActionController::UrlRewriter.old_new(MockRequest.new(
+      "http://",
+      "www.singlefile.com", 
+      80,
+      "/library/books/ISBN/0743536703/", 
+      { "type" => "ISBN", "code" => "0743536703" }
+    ), "books", "index")
+    
+    @clean_urls = [
+      ActionController::UrlRewriter.old_new(MockRequest.new(
+        "http://", "www.singlefile.com", 80, "/identity/", {}
+      ), "identity", "index"),
+      ActionController::UrlRewriter.old_new(MockRequest.new(
+        "http://", "www.singlefile.com", 80, "/identity", {}
+      ), "identity", "index")
+    ]
+
+    @clean_url_with_id = ActionController::UrlRewriter.old_new(MockRequest.new(
+      "http://", "www.singlefile.com", 80, "/identity/show/5", { "id" => "5" }
+    ), "identity", "show")
+
+    @clean_url_with_same_action_and_controller_name = ActionController::UrlRewriter.old_new(MockRequest.new(
+      "http://", "www.singlefile.com", 80, "/login/login", {  }
+    ), "login", "login")
+
+    @clean_url_with_same_action_and_controller_and_module_name = ActionController::UrlRewriter.old_new(MockRequest.new(
+      "http://", "www.singlefile.com", 80, "/login/login/login", { "module" => "login" }
+    ), "login", "login")
+
+    @clean_url_with_id_as_char = ActionController::UrlRewriter.old_new(MockRequest.new(
+      "http://", "www.singlefile.com", 80, "/teachers/show/t", { "id" => "t" }
+    ), "teachers", "show")
+  end
+
+  def test_clean_action
+    assert_equal "http://www.singlefile.com/library/books/ISBN/0743536703/edit", @library_url.rewrite(:action => "edit")
+  end
+
+  def test_clean_action_to_another_host
+    assert_equal(
+      "http://www.booksphere.com/library/books/ISBN/0743536703/edit", 
+      @library_url.rewrite(:action => "edit", :host => "www.booksphere.com")
+    )
+  end
+
+  def test_clean_action_to_another_host_and_protocol
+    assert_equal(
+      "https://www.booksphere.com/library/books/ISBN/0743536703/edit", 
+      @library_url.rewrite(:action => "edit", :host => "www.booksphere.com", :protocol => "https://")
+    )
+  end
+
+  def test_clean_action_with_only_path
+    assert_equal "/library/books/ISBN/0743536703/edit", @library_url.rewrite(:action => "edit", :only_path => true)
+  end
+
+  def test_action_from_index
+    assert_equal "http://www.singlefile.com/library/books/ISBN/0743536703/edit", @library_url_on_index.rewrite(:action => "edit")
+  end
+
+  def test_action_from_index_on_clean
+    @clean_urls.each do |url|
+      assert_equal "http://www.singlefile.com/identity/edit", url.rewrite(:action => "edit")
+    end
+  end
+
+  def test_action_without_prefix
+    assert_equal "http://www.singlefile.com/library/books/", @library_url.rewrite(:action => "index", :action_prefix => "")
+  end
+
+  def test_action_with_prefix
+    assert_equal(
+      "http://www.singlefile.com/library/books/XTC/123/show", 
+      @library_url.rewrite(:action => "show", :action_prefix => "XTC/123")
+    )
+  end
+
+  def test_action_prefix_alone
+    assert_equal(
+      "http://www.singlefile.com/library/books/XTC/123/",
+      @library_url.rewrite(:action_prefix => "XTC/123")
+    )
+  end
+
+  def test_action_with_suffix
+    assert_equal(
+      "http://www.singlefile.com/library/books/show/XTC/123",
+      @library_url.rewrite(:action => "show", :action_prefix => "", :action_suffix => "XTC/123")
+    )
+  end
+
+  def test_clean_controller
+    assert_equal "http://www.singlefile.com/library/settings/", @library_url.rewrite(:controller => "settings")
+  end
+
+  def test_clean_controller_prefix
+    assert_equal "http://www.singlefile.com/shop/", @library_url.rewrite(:controller_prefix => "shop")
+  end
+
+  def test_clean_controller_with_module
+    assert_equal "http://www.singlefile.com/shop/purchases/", @library_url.rewrite(:module => "shop", :controller => "purchases")
+  end
+  
+  def test_getting_out_of_a_module
+    assert_equal "http://www.singlefile.com/purchases/", @library_url_using_module.rewrite(:module => false, :controller => "purchases")
+  end
+
+  def test_controller_and_action
+    assert_equal "http://www.singlefile.com/library/settings/show", @library_url.rewrite(:controller => "settings", :action => "show")
+  end
+
+  def test_controller_and_action_and_anchor
+    assert_equal(
+      "http://www.singlefile.com/library/settings/show#5", 
+      @library_url.rewrite(:controller => "settings", :action => "show", :anchor => "5")
+    )
+  end
+
+  def test_controller_and_action_and_empty_overwrite_params_and_anchor
+    assert_equal(
+      "http://www.singlefile.com/library/settings/show?code=0743536703&type=ISBN#5", 
+      @library_url.rewrite(:controller => "settings", :action => "show", :overwrite_params => {},  :anchor => "5")
+    )
+  end
+  
+  def test_controller_and_action_and_overwrite_params_and_anchor
+    assert_equal(
+      "http://www.singlefile.com/library/settings/show?code=0000001&type=ISBN#5", 
+      @library_url.rewrite(:controller => "settings", :action => "show", :overwrite_params => {"code"=>"0000001"},  :anchor => "5")
+    )
+  end
+
+  def test_controller_and_action_and_overwrite_params_with_nil_value_and_anchor
+    assert_equal(
+      "http://www.singlefile.com/library/settings/show?type=ISBN#5", 
+      @library_url.rewrite(:controller => "settings", :action => "show", :overwrite_params => {"code" => nil},  :anchor => "5")
+    )
+  end
+
+  def test_controller_and_action_params_and_overwrite_params_and_anchor
+    assert_equal(
+      "http://www.singlefile.com/library/settings/show?code=0000001&version=5.0#5", 
+      @library_url.rewrite(:controller => "settings", :action => "show", :params=>{"version" => "5.0"},  :overwrite_params => {"code"=>"0000001"},  :anchor => "5")
+    )
+  end
+
+  def test_controller_and_action_and_params_anchor
+    assert_equal(
+      "http://www.singlefile.com/library/settings/show?update=1#5", 
+      @library_url.rewrite(:controller => "settings", :action => "show", :params => { "update" => "1"}, :anchor => "5")
+    )
+  end
+
+  def test_controller_and_index_action
+    assert_equal "http://www.singlefile.com/library/settings/", @library_url.rewrite(:controller => "settings", :action => "index")
+  end
+
+  def test_same_controller_and_action_names
+    assert_equal "http://www.singlefile.com/login/logout", @clean_url_with_same_action_and_controller_name.rewrite(:action => "logout")
+  end
+
+  def xtest_same_module_and_controller_and_action_names
+    assert_equal "http://www.singlefile.com/login/login/logout", @clean_url_with_same_action_and_controller_and_module_name.rewrite(:action => "logout")
+  end
+
+  def test_controller_and_action_with_same_name_as_controller
+    @clean_urls.each do |url|
+      assert_equal "http://www.singlefile.com/anything/identity", url.rewrite(:controller => "anything", :action => "identity")
+    end
+  end
+
+  def test_controller_and_index_action_without_controller_prefix
+    assert_equal(
+      "http://www.singlefile.com/settings/", 
+      @library_url.rewrite(:controller => "settings", :action => "index", :controller_prefix => "")
+    )
+  end
+
+  def test_controller_and_index_action_with_controller_prefix
+    assert_equal(
+      "http://www.singlefile.com/fantastic/settings/show", 
+      @library_url.rewrite(:controller => "settings", :action => "show", :controller_prefix => "fantastic")
+    )
+  end
+
+  def test_path_parameters
+    assert_equal "http://www.singlefile.com/library/books/EXBC/0743536703/show", @library_url.rewrite(:path_params => {"type" => "EXBC"})
+  end
+  
+  def test_parameters
+    assert_equal(
+      "http://www.singlefile.com/library/books/ISBN/0743536703/show?delete=1&name=David", 
+      @library_url.rewrite(:params => {"delete" => "1", "name" => "David"})
+    )
+  end
+
+  def test_parameters_with_id
+    @clean_urls.each do |url|
+      assert_equal(
+        "http://www.singlefile.com/identity/show?name=David&id=5", 
+        url.rewrite(
+          :action => "show",
+          :params => { "id" => "5", "name" => "David" }
+        )
+      )
+    end
+  end
+
+  def test_parameters_with_array
+    @clean_urls.each do |url|
+      assert_equal(
+        "http://www.singlefile.com/identity/show?id[]=3&id[]=5&id[]=10",
+	url.rewrite(
+		:action => "show",
+		:params => { 'id' => [ 3, 5, 10 ] } )
+      )
+    end
+  end
+
+  def test_action_with_id
+   assert_equal(
+      "http://www.singlefile.com/identity/show/7", 
+      @clean_url_with_id.rewrite(
+        :action => "show", 
+        :id => 7
+      )
+    )
+    @clean_urls.each do |url|
+      assert_equal(
+        "http://www.singlefile.com/identity/index/7", 
+        url.rewrite(:id => 7)
+      )
+    end
+  end
+
+  def test_parameters_with_id_and_away
+    assert_equal(
+      "http://www.singlefile.com/identity/show/25?name=David", 
+      @clean_url_with_id.rewrite(
+        :path_params => { "id" => "25" },
+        :params => { "name" => "David" }
+      )
+    )
+  end
+
+  def test_parameters_with_index_and_id
+    @clean_urls.each do |url|
+      assert_equal(
+        "http://www.singlefile.com/identity/index/25?name=David", 
+        url.rewrite(
+          :path_params => { "id" => "25" },
+          :params => { "name" => "David" }
+        )
+      )
+    end
+  end
+
+  def test_action_going_away_from_id
+    assert_equal(
+      "http://www.singlefile.com/identity/list", 
+      @clean_url_with_id.rewrite(
+        :action => "list"
+      )
+    )
+  end
+
+  def test_parameters_with_direct_id_and_away
+    assert_equal(
+      "http://www.singlefile.com/identity/show/25?name=David", 
+      @clean_url_with_id.rewrite(
+        :id => "25",
+        :params => { "name" => "David" }
+      )
+    )
+  end
+
+  def test_parameters_with_direct_id_and_away
+    assert_equal(
+      "http://www.singlefile.com/store/open/25?name=David", 
+      @clean_url_with_id.rewrite(
+        :controller => "store",
+        :action => "open",
+        :id => "25",
+        :params => { "name" => "David" }
+      )
+    )
+  end
+
+  def test_parameters_to_id
+    @clean_urls.each do |url|
+      %w(show index).each do |action|
+        assert_equal(
+          "http://www.singlefile.com/identity/#{action}/25?name=David", 
+          url.rewrite(
+            :action => action,
+            :path_params => { "id" => "25" },
+            :params => { "name" => "David" }
+          )
+        )
+      end
+    end
+  end
+
+  def test_parameters_from_id
+    assert_equal(
+      "http://www.singlefile.com/identity/", 
+      @clean_url_with_id.rewrite(
+        :action => "index"
+      )
+    )
+  end
+  
+  def test_id_as_char_and_part_of_controller
+    assert_equal(
+      "http://www.singlefile.com/teachers/skill/5", 
+      @clean_url_with_id_as_char.rewrite(
+        :action => "skill",
+        :id => 5
+      )
+    )
+  end
+
+  def test_from_clean_to_library
+    @clean_urls.each do |url|
+      assert_equal(
+        "http://www.singlefile.com/library/books/ISBN/0743536703/show?delete=1&name=David", 
+        url.rewrite(
+          :controller_prefix => "library",
+          :controller => "books", 
+          :action_prefix => "ISBN/0743536703",
+          :action => "show", 
+          :params => { "delete" => "1", "name" => "David" }
+        )
+      )
+    end
+  end
+  
+  def test_from_library_to_clean
+    assert_equal(
+      "http://www.singlefile.com/identity/", 
+      @library_url.rewrite(
+        :controller => "identity", :controller_prefix => ""
+      )
+    )
+  end
+  
+  def test_from_another_port
+    @library_url = ActionController::UrlRewriter.old_new(MockRequest.new(
+      "http://",
+      "www.singlefile.com", 
+      8080,
+      "/library/books/ISBN/0743536703/show", 
+      { "type" => "ISBN", "code" => "0743536703" }
+    ), "books", "show")
+
+    assert_equal(
+      "http://www.singlefile.com:8080/identity/", 
+      @library_url.rewrite(
+        :controller => "identity", :controller_prefix => ""
+      )
+    )
+  end
+  
+  def test_basecamp
+    basecamp_url = ActionController::UrlRewriter.old_new(MockRequest.new(
+      "http://",
+      "projects.basecamp", 
+      80,
+      "/clients/disarray/1/msg/transcripts/", 
+      {"category_name"=>"transcripts", "client_name"=>"disarray", "action"=>"index", "controller"=>"msg", "project_name"=>"1"}
+    ), "msg", "index")
+    
+    assert_equal(
+      "http://projects.basecamp/clients/disarray/1/msg/transcripts/1/comments", 
+      basecamp_url.rewrite(:action_prefix => "transcripts/1", :action => "comments")
+    )
+  end
+
+  def test_on_explicit_index_page # My index page is very modest, thank you...
+    url = ActionController::UrlRewriter.old_new(
+      MockRequest.new(
+        "http://", "example.com", 80, "/controller/index",
+        {"controller"=>"controller", "action"=>"index"}
+      ), "controller", "index"
+    )
+    assert_equal("http://example.com/controller/foo", url.rewrite(:action => 'foo'))
+  end
+
+  def test_rewriting_on_similar_fragments
+    url = UrlMockFactory.create("/advertisements/advert/", {"controller"=>"advert", "action"=>"index"})
+    assert_equal("http://example.com/advertisements/advert/news", url.rewrite(:action => 'news'))
+  end
+
+  def test_rewriting_on_similar_fragments_with_action_prefixes
+    url = UrlMockFactory.create(
+      "/clients/prall/1/msg/all/", 
+      { "category_name"=>"all", "client_name"=>"prall", "action"=>"index", "controller"=>"msg", "project_name"=>"1"}
+    )
+
+    assert_equal(
+      "http://example.com/clients/prall/1/msg/all/new", 
+      url.rewrite({ :controller => "msg", :action_prefix => "all", :action => "new" })
+    )
+
+    url = UrlMockFactory.create(
+      "/clients/prall/1/msg/all/", 
+      { "category_name"=>"all", "client_name"=>"prall", "action"=>"index", "controller"=>"msg", "project_name"=>"1"}
+    )
+
+    assert_equal(
+      "http://example.com/clients/prall/1/msg/allous/new", 
+      url.rewrite({ :controller => "msg", :action_prefix => "allous", :action => "new" })
+    )
+  end
+
+  def test_clean_application_prefix
+    assert_equal "http://www.singlefile.com/namespace/library/books/ISBN/0743536703/show",
+      @library_url.rewrite(:application_prefix => "/namespace")
+  end
+
+  def test_clean_application_prefix_with_controller_prefix
+    assert_equal "http://www.singlefile.com/namespace/shop/",
+      @library_url.rewrite(:application_prefix => "/namespace",
+                           :controller_prefix => "shop" )
+  end
+
+  def test_blank_application_prefix
+    assert_equal "http://www.singlefile.com/library/books/ISBN/0743536703/show",
+      @library_url.rewrite(:application_prefix => "")
+  end
+
+  def test_nil_application_prefix
+    assert_equal "http://www.singlefile.com/library/books/ISBN/0743536703/show",
+      @library_url.rewrite(:application_prefix => nil)
+  end
+end
-- 
cgit v1.2.3