Class LegacyRouteSetTests < Test::Unit::TestCase

# File actionpack/test/controller/routing_test.rb, line 84
def get(uri_or_host, path = nil, port = nil)
  host = uri_or_host.host unless path
  path ||= uri_or_host.path

  params = {'PATH_INFO'      => path,
            'REQUEST_METHOD' => 'GET',
            'HTTP_HOST'      => host}

  @rs.call(params)[2].join
end

# File actionpack/test/controller/routing_test.rb, line 223
def matches? request
  request.subdomain.present? and request.subdomain != 'clients'
end

# File actionpack/test/controller/routing_test.rb, line 79
def setup
  @rs       = ::ActionDispatch::Routing::RouteSet.new
  @response = nil
end

# File actionpack/test/controller/routing_test.rb, line 470
def setup_for_named_route(options = {})
  MockController.build(rs.url_helpers, options).new
end

# File actionpack/test/controller/routing_test.rb, line 730
def setup_request_method_routes_for(method)
  rs.draw do
    match '/match' => 'books#get', :via => :get
    match '/match' => 'books#post', :via => :post
    match '/match' => 'books#put', :via => :put
    match '/match' => 'books#delete', :via => :delete
  end
end

# File actionpack/test/controller/routing_test.rb, line 625
def test_action_expiry
  @rs.draw { match ':controller(/:action(/:id))' }
  assert_equal '/content', url_for(rs, { :controller => 'content' }, { :controller => 'content', :action => 'show' })
end

# File actionpack/test/controller/routing_test.rb, line 580
def test_backwards
  rs.draw do
    match 'page/:id(/:action)' => 'pages#show'
    match ':controller(/:action(/:id))'
  end

  assert_equal '/page/20',   url_for(rs, { :id => 20 }, { :controller => 'pages', :action => 'show' })
  assert_equal '/page/20',   url_for(rs, { :controller => 'pages', :id => 20, :action => 'show' })
  assert_equal '/pages/boo', url_for(rs, { :controller => 'pages', :action => 'boo' })
end

# File actionpack/test/controller/routing_test.rb, line 399
def test_basic_named_route
  rs.draw do
    root :to => 'content#list', :as => 'home'
  end
  assert_equal("http://test.host/", setup_for_named_route.send(:home_url))
end

# File actionpack/test/controller/routing_test.rb, line 642
def test_both_requirement_and_optional
  rs.draw do
    match('test(/:year)' => 'post#show', :as => 'blog',
      :defaults => { :year => nil },
      :constraints => { :year => /\d{4}/ }
    )
    match ':controller/:action/:id'
  end

  assert_equal '/test', url_for(rs, { :controller => 'post', :action => 'show' })
  assert_equal '/test', url_for(rs, { :controller => 'post', :action => 'show', :year => nil })

  assert_equal("http://test.host/test", setup_for_named_route.send(:blog_url))
end

# File actionpack/test/controller/routing_test.rb, line 512
def test_changing_controller
  @rs.draw { match ':controller/:action/:id' }

  assert_equal '/admin/stuff/show/10',
      url_for(rs, {:controller => 'stuff', :action => 'show', :id => 10},
                  {:controller => 'admin/user', :action => 'index'})
end

# File actionpack/test/controller/routing_test.rb, line 221
def test_class_and_lambda_constraints
  subdomain = Class.new {
    def matches? request
      request.subdomain.present? and request.subdomain != 'clients'
    end
  }

  @rs.draw do
    match '/', :constraints => subdomain.new,
               :to          => lambda { |env| [200, {}, %w{default}] }
    match '/', :constraints => { :subdomain => 'clients' },
               :to          => lambda { |env| [200, {}, %w{clients}] }
  end

  assert_equal 'default', get(URI('http://www.example.org/'))
  assert_equal 'clients', get(URI('http://clients.example.org/'))
end

# File actionpack/test/controller/routing_test.rb, line 119
def test_dash_with_custom_regexp
  rs.draw do
    match '/:artist/:song-omg', :constraints => { :song => /\d+/ }, :to => lambda { |env|
      resp = JSON.dump env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
      [200, {}, [resp]]
    }
  end

  hash = JSON.load get(URI('http://example.org/journey/123-omg'))
  assert_equal({"artist"=>"journey", "song"=>"123"}, hash)
  assert_equal 'Not Found', get(URI('http://example.org/journey/faithfully-omg'))
end

# File actionpack/test/controller/routing_test.rb, line 292
def test_default_setup
  @rs.draw { match '/:controller(/:action(/:id))' }
  assert_equal({:controller => "content", :action => 'index'}, rs.recognize_path("/content"))
  assert_equal({:controller => "content", :action => 'list'},  rs.recognize_path("/content/list"))
  assert_equal({:controller => "content", :action => 'show', :id => '10'}, rs.recognize_path("/content/show/10"))

  assert_equal({:controller => "admin/user", :action => 'show', :id => '10'}, rs.recognize_path("/admin/user/show/10"))

  assert_equal '/admin/user/show/10', url_for(rs, { :controller => 'admin/user', :action => 'show', :id => 10 })

  assert_equal '/admin/user/show',    url_for(rs, { :action => 'show' }, { :controller => 'admin/user', :action => 'list', :id => '10' })
  assert_equal '/admin/user/list/10', url_for(rs, {}, { :controller => 'admin/user', :action => 'list', :id => '10' })

  assert_equal '/admin/stuff', url_for(rs, { :controller => 'stuff' }, { :controller => 'admin/user', :action => 'list', :id => '10' })
  assert_equal '/stuff',       url_for(rs, { :controller => '/stuff' }, { :controller => 'admin/user', :action => 'list', :id => '10' })
end

# File actionpack/test/controller/routing_test.rb, line 276
def test_draw_with_block_arity_one_raises
  assert_raise(RuntimeError) do
    @rs.draw { |map| map.match '/:controller(/:action(/:id))' }
  end
end

# File actionpack/test/controller/routing_test.rb, line 562
def test_dynamic_path_allowed
  rs.draw do
    match '*path' => 'content#show_file'
  end

  assert_equal '/pages/boo',
      url_for(rs, { :controller => 'content', :action => 'show_file', :path => %w(pages boo) })
end

# File actionpack/test/controller/routing_test.rb, line 571
def test_dynamic_recall_paths_allowed
  rs.draw do
    match '*path' => 'content#show_file'
  end

  assert_equal '/pages/boo',
      url_for(rs, {}, { :controller => 'content', :action => 'show_file', :path => %w(pages boo) })
end

# File actionpack/test/controller/routing_test.rb, line 254
def test_empty_string_match
  rs.draw do
    get '/:username', :constraints => { :username => /[^\/]+/ },
                     :to => lambda { |e| [200, {}, ['foo']] }
  end
  assert_equal 'Not Found', get(URI('http://example.org/'))
  assert_equal 'foo', get(URI('http://example.org/hello'))
end

# File actionpack/test/controller/routing_test.rb, line 797
def test_failed_constraints_raises_exception_with_violated_constraints
  rs.draw do
    match 'foos/:id' => 'foos#show', :as => 'foo_with_requirement', :constraints => { :id => /\d+/ }
  end

  assert_raise(ActionController::RoutingError) do
    setup_for_named_route.send(:foo_with_requirement_url, "I am Against the constraints")
  end
end

# File actionpack/test/controller/routing_test.rb, line 107
def test_id_with_dash
  rs.draw do
    match '/journey/:id', :to => lambda { |env|
      resp = JSON.dump env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
      [200, {}, [resp]]
    }
  end

  hash = JSON.load get(URI('http://example.org/journey/faithfully-omg'))
  assert_equal({"id"=>"faithfully-omg"}, hash)
end

# File actionpack/test/controller/routing_test.rb, line 309
def test_ignores_leading_slash
  @rs.clear!
  @rs.draw { match '/:controller(/:action(/:id))'}
  test_default_setup
end

# File actionpack/test/controller/routing_test.rb, line 239
def test_lambda_constraints
  @rs.draw do
    match '/', :constraints => lambda { |req|
      req.subdomain.present? and req.subdomain != "clients" },
               :to          => lambda { |env| [200, {}, %w{default}] }

    match '/', :constraints => lambda { |req|
      req.subdomain.present? && req.subdomain == "clients" },
               :to          => lambda { |env| [200, {}, %w{clients}] }
  end

  assert_equal 'default', get(URI('http://www.example.org/'))
  assert_equal 'clients', get(URI('http://clients.example.org/'))
end

# File actionpack/test/controller/routing_test.rb, line 689
def test_named_root_url_generation_with_controller_and_action
  rs.draw do
     root :to => "content#index", :as => 'home'
  end

  assert_equal '/', url_for(rs, { :controller => 'content', :action => 'index' })
  assert_equal '/', url_for(rs, { :controller => 'content' })

  assert_equal("http://test.host/", setup_for_named_route.send(:home_url))
end

# File actionpack/test/controller/routing_test.rb, line 700
def test_named_route_method
  rs.draw do
    match 'categories' => 'content#categories', :as => 'categories'
    match ':controller(/:action(/:id))'
  end

  assert_equal '/categories', url_for(rs, { :controller => 'content', :action => 'categories' })
  assert_equal '/content/hi', url_for(rs, { :controller => 'content', :action => 'hi' })
end

# File actionpack/test/controller/routing_test.rb, line 480
def test_named_route_root
  rs.draw do
    root :to => "hello#index"
  end
  routes = setup_for_named_route
  assert_equal("http://test.host/", routes.send(:root_url))
  assert_equal("/", routes.send(:root_path))
end

# File actionpack/test/controller/routing_test.rb, line 489
def test_named_route_root_with_trailing_slash
  rs.draw do
    root :to => "hello#index"
  end

  routes = setup_for_named_route(:trailing_slash => true)
  assert_equal("http://test.host/", routes.send(:root_url))
  assert_equal("http://test.host/?foo=bar", routes.send(:root_url, :foo => :bar))
end

# File actionpack/test/controller/routing_test.rb, line 435
def test_named_route_with_blank_path_prefix
  rs.draw do
    scope "" do
      match 'page' => 'content#show_page', :as => 'page'
    end
  end

  assert_equal("http://test.host/page",
      setup_for_named_route.send(:page_url))
end

# File actionpack/test/controller/routing_test.rb, line 415
def test_named_route_with_default
  rs.draw do
    match 'page/:title' => 'content#show_page', :title => 'AboutPage', :as => 'page'
  end

  assert_equal("http://test.host/page/AboutRails",
      setup_for_named_route.send(:page_url, :title => "AboutRails"))
end

# File actionpack/test/controller/routing_test.rb, line 446
def test_named_route_with_nested_controller
  rs.draw do
    match 'admin/user' => 'admin/user#index', :as => "users"
  end

  assert_equal("http://test.host/admin/user",
      setup_for_named_route.send(:users_url))
end

# File actionpack/test/controller/routing_test.rb, line 406
def test_named_route_with_option
  rs.draw do
    match 'page/:title' => 'content#show_page', :as => 'page'
  end

  assert_equal("http://test.host/page/new%20stuff",
      setup_for_named_route.send(:page_url, :title => 'new stuff'))
end

# File actionpack/test/controller/routing_test.rb, line 424
def test_named_route_with_path_prefix
  rs.draw do
    scope "my" do
      match 'page' => 'content#show_page', :as => 'page'
    end
  end

  assert_equal("http://test.host/my/page",
      setup_for_named_route.send(:page_url))
end

# File actionpack/test/controller/routing_test.rb, line 499
def test_named_route_with_regexps
  rs.draw do
    match 'page/:year/:month/:day/:title' => 'page#show', :as => 'article',
      :year => /\d+/, :month => /\d+/, :day => /\d+/
    match ':controller/:action/:id'
  end

  routes = setup_for_named_route

  assert_equal "http://test.host/page/2005/6/10/hi",
    routes.send(:article_url, :title => 'hi', :day => 10, :year => 2005, :month => 6)
end

# File actionpack/test/controller/routing_test.rb, line 474
def test_named_route_without_hash
  rs.draw do
    match ':controller/:action/:id', :as => 'normal'
  end
end

# File actionpack/test/controller/routing_test.rb, line 710
def test_named_routes_array
  test_named_route_method
  assert_equal [:categories], rs.named_routes.names
end

# File actionpack/test/controller/routing_test.rb, line 715
def test_nil_defaults
  rs.draw do
    match 'journal' => 'content#list_journal',
      :date => nil, :user_id => nil
    match ':controller/:action/:id'
  end

  assert_equal '/journal', url_for(rs, {
    :controller => 'content',
    :action => 'list_journal',
    :date => nil,
    :user_id => nil
  })
end

# File actionpack/test/controller/routing_test.rb, line 546
def test_non_controllers_cannot_be_matched
  rs.draw do
    match ':controller/:action/:id'
  end
  assert_raise(ActionController::RoutingError) { rs.recognize_path("/not_a/show/10") }
end

# File actionpack/test/controller/routing_test.rb, line 263
def test_non_greedy_glob_regexp
  params = nil
  rs.draw do
    get '/posts/:id(/*filters)', :constraints => { :filters => /.+?/ },
      :to => lambda { |e|
      params = e["action_dispatch.request.path_parameters"]
      [200, {}, ['foo']]
    }
  end
  assert_equal 'foo', get(URI('http://example.org/posts/1/foo.js'))
  assert_equal({:id=>"1", :filters=>"foo", :format=>"js"}, params)
end

# File actionpack/test/controller/routing_test.rb, line 455
def test_optimised_named_route_with_host
  rs.draw do
    match 'page' => 'content#show_page', :as => 'pages', :host => 'foo.com'
  end
  routes = setup_for_named_route
  routes.expects(:url_for).with({
    :host => 'foo.com',
    :only_path => false,
    :controller => 'content',
    :action => 'show_page',
    :use_route => 'pages'
  }).once
  routes.send(:pages_url)
end

# File actionpack/test/controller/routing_test.rb, line 182
def test_optional_star_paths_are_greedy
  rs.draw do
    match "/(*filters)", :to => lambda { |env|
      x = env["action_dispatch.request.path_parameters"][:filters]
      [200, {}, [x]]
    }, :format => false
  end

  u = URI('http://example.org/ne_27.065938,-80.6092/sw_25.489856,-82.542794')
  assert_equal u.path.sub(/^\//, ''), get(u)
end

# File actionpack/test/controller/routing_test.rb, line 194
def test_optional_star_paths_are_greedy_but_not_too_much
  rs.draw do
    match "/(*filters)", :to => lambda { |env|
      x = JSON.dump env["action_dispatch.request.path_parameters"]
      [200, {}, [x]]
    }
  end

  expected = { "filters" => "ne_27.065938,-80.6092/sw_25.489856,-82",
               "format"  => "542794" }
  u = URI('http://example.org/ne_27.065938,-80.6092/sw_25.489856,-82.542794')
  assert_equal expected, JSON.parse(get(u))
end

# File actionpack/test/controller/routing_test.rb, line 520
def test_paths_escaped
  rs.draw do
    match 'file/*path' => 'content#show_file', :as => 'path'
    match ':controller/:action/:id'
  end

  # No + to space in URI escaping, only for query params.
  results = rs.recognize_path "/file/hello+world/how+are+you%3F"
  assert results, "Recognition should have succeeded"
  assert_equal 'hello+world/how+are+you?', results[:path]

  # Use %20 for space instead.
  results = rs.recognize_path "/file/hello%20world/how%20are%20you%3F"
  assert results, "Recognition should have succeeded"
  assert_equal 'hello world/how are you?', results[:path]
end

# File actionpack/test/controller/routing_test.rb, line 537
def test_paths_slashes_unescaped_with_ordered_parameters
  rs.draw do
    match '/file/*path' => 'content#index', :as => 'path'
  end

  # No / to %2F in URI, only for query params.
  assert_equal("/file/hello/world", setup_for_named_route.send(:path_path, ['hello', 'world']))
end

# File actionpack/test/controller/routing_test.rb, line 132
def test_pre_dash
  rs.draw do
    match '/:artist/omg-:song', :to => lambda { |env|
      resp = JSON.dump env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
      [200, {}, [resp]]
    }
  end

  hash = JSON.load get(URI('http://example.org/journey/omg-faithfully'))
  assert_equal({"artist"=>"journey", "song"=>"faithfully"}, hash)
end

# File actionpack/test/controller/routing_test.rb, line 144
def test_pre_dash_with_custom_regexp
  rs.draw do
    match '/:artist/omg-:song', :constraints => { :song => /\d+/ }, :to => lambda { |env|
      resp = JSON.dump env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
      [200, {}, [resp]]
    }
  end

  hash = JSON.load get(URI('http://example.org/journey/omg-123'))
  assert_equal({"artist"=>"journey", "song"=>"123"}, hash)
  assert_equal 'Not Found', get(URI('http://example.org/journey/omg-faithfully'))
end

# File actionpack/test/controller/routing_test.rb, line 747
def test_recognize_array_of_methods
  rs.draw do
    match '/match' => 'books#get_or_post', :via => [:get, :post]
    match '/match' => 'books#not_get_or_post'
  end

  params = rs.recognize_path("/match", :method => :post)
  assert_equal 'get_or_post', params[:action]

  params = rs.recognize_path("/match", :method => :put)
  assert_equal 'not_get_or_post', params[:action]
end

# File actionpack/test/controller/routing_test.rb, line 208
def test_regexp_precidence
  @rs.draw do
    match '/whois/:domain', :constraints => {
      :domain => /\w+\.[\w\.]+/ },
      :to     => lambda { |env| [200, {}, %w{regexp}] }

    match '/whois/:id', :to => lambda { |env| [200, {}, %w{id}] }
  end

  assert_equal 'regexp', get(URI('http://example.org/whois/example.org'))
  assert_equal 'id', get(URI('http://example.org/whois/123'))
end

# File actionpack/test/controller/routing_test.rb, line 630
def test_requirement_should_prevent_optional_id
  rs.draw do
    match 'post/:id' => 'post#show', :constraints => {:id => /\d+/}, :as => 'post'
  end

  assert_equal '/post/10', url_for(rs, { :controller => 'post', :action => 'show', :id => 10 })

  assert_raise ActionController::RoutingError do
    url_for(rs, { :controller => 'post', :action => 'show' })
  end
end

# File actionpack/test/controller/routing_test.rb, line 680
def test_root_url_generation_with_controller_and_action
  rs.draw do
    root :to => "content#index"
  end

  assert_equal '/', url_for(rs, { :controller => 'content', :action => 'index' })
  assert_equal '/', url_for(rs, { :controller => 'content' })
end

# File actionpack/test/controller/routing_test.rb, line 345
def test_route_with_colon_first
  rs.draw do
    match '/:controller/:action/:id', :action => 'index', :id => nil
    match ':url', :controller => 'tiny_url', :action => 'translate'
  end
end

# File actionpack/test/controller/routing_test.rb, line 591
def test_route_with_fixnum_default
  rs.draw do
    match 'page(/:id)' => 'content#show_page', :id => 1
    match ':controller/:action/:id'
  end

  assert_equal '/page',    url_for(rs, { :controller => 'content', :action => 'show_page' })
  assert_equal '/page',    url_for(rs, { :controller => 'content', :action => 'show_page', :id => 1 })
  assert_equal '/page',    url_for(rs, { :controller => 'content', :action => 'show_page', :id => '1' })
  assert_equal '/page/10', url_for(rs, { :controller => 'content', :action => 'show_page', :id => 10 })

  assert_equal({:controller => "content", :action => 'show_page', :id => 1 }, rs.recognize_path("/page"))
  assert_equal({:controller => "content", :action => 'show_page', :id => '1'}, rs.recognize_path("/page/1"))
  assert_equal({:controller => "content", :action => 'show_page', :id => '10'}, rs.recognize_path("/page/10"))
end

# File actionpack/test/controller/routing_test.rb, line 367
def test_route_with_regexp_and_captures_for_controller
  rs.draw do
    match '/:controller(/:action(/:id))', :controller => /admin\/(accounts|users)/
  end
  assert_equal({:controller => "admin/accounts", :action => "index"}, rs.recognize_path("/admin/accounts"))
  assert_equal({:controller => "admin/users", :action => "index"}, rs.recognize_path("/admin/users"))
  assert_raise(ActionController::RoutingError) { rs.recognize_path("/admin/products") }
end

# File actionpack/test/controller/routing_test.rb, line 376
def test_route_with_regexp_and_dot
  rs.draw do
    match ':controller/:action/:file',
              :controller => /admin|user/,
              :action => /upload|download/,
              :defaults => {:file => nil},
              :constraints => {:file => %r{[^/]+(\.[^/]+)?}}
  end
  # Without a file extension
  assert_equal '/user/download/file',
    url_for(rs, { :controller => "user", :action => "download", :file => "file" })

  assert_equal({:controller => "user", :action => "download", :file => "file"},
    rs.recognize_path("/user/download/file"))

  # Now, let's try a file with an extension, really a dot (.)
  assert_equal '/user/download/file.jpg',
    url_for(rs, { :controller => "user", :action => "download", :file => "file.jpg" })

  assert_equal({:controller => "user", :action => "download", :file => "file.jpg"},
    rs.recognize_path("/user/download/file.jpg"))
end

# File actionpack/test/controller/routing_test.rb, line 352
def test_route_with_regexp_for_controller
  rs.draw do
    match ':controller/:admintoken(/:action(/:id))', :controller => /admin\/.+/
    match '/:controller(/:action(/:id))'
  end

  assert_equal({:controller => "admin/user", :admintoken => "foo", :action => "index"},
      rs.recognize_path("/admin/user/foo"))
  assert_equal({:controller => "content", :action => "foo"},
      rs.recognize_path("/content/foo"))

  assert_equal '/admin/user/foo', url_for(rs, { :controller => "admin/user", :admintoken => "foo", :action => "index" })
  assert_equal '/content/foo',    url_for(rs, { :controller => "content", :action => "foo" })
end

# File actionpack/test/controller/routing_test.rb, line 608
def test_route_with_text_default
  rs.draw do
    match 'page/:id' => 'content#show_page', :id => 1
    match ':controller/:action/:id'
  end

  assert_equal '/page/foo', url_for(rs, { :controller => 'content', :action => 'show_page', :id => 'foo' })
  assert_equal({ :controller => "content", :action => 'show_page', :id => 'foo' }, rs.recognize_path("/page/foo"))

  token = "\321\202\320\265\320\272\321\201\321\202" # 'text' in Russian
  token.force_encoding(Encoding::BINARY) if token.respond_to?(:force_encoding)
  escaped_token = CGI::escape(token)

  assert_equal '/page/' + escaped_token, url_for(rs, { :controller => 'content', :action => 'show_page', :id => token })
  assert_equal({ :controller => "content", :action => 'show_page', :id => token }, rs.recognize_path("/page/#{escaped_token}"))
end

# File actionpack/test/controller/routing_test.rb, line 807
def test_routes_changed_correctly_after_clear
  rs = ::ActionDispatch::Routing::RouteSet.new
  rs.draw do
    match 'ca' => 'ca#aa'
    match 'cb' => 'cb#ab'
    match 'cc' => 'cc#ac'
    match ':controller/:action/:id'
    match ':controller/:action/:id.:format'
  end

  hash = rs.recognize_path "/cc"

  assert_not_nil hash
  assert_equal %w(cc ac), [hash[:controller], hash[:action]]

  rs.draw do
    match 'cb' => 'cb#ab'
    match 'cc' => 'cc#ac'
    match ':controller/:action/:id'
    match ':controller/:action/:id.:format'
  end

  hash = rs.recognize_path "/cc"

  assert_not_nil hash
  assert_equal %w(cc ac), [hash[:controller], hash[:action]]
end

# File actionpack/test/controller/routing_test.rb, line 657
def test_set_to_nil_forgets
  rs.draw do
    match 'pages(/:year(/:month(/:day)))' => 'content#list_pages', :month => nil, :day => nil
    match ':controller/:action/:id'
  end

  assert_equal '/pages/2005',
    url_for(rs, { :controller => 'content', :action => 'list_pages', :year => 2005 })
  assert_equal '/pages/2005/6',
    url_for(rs, { :controller => 'content', :action => 'list_pages', :year => 2005, :month => 6 })
  assert_equal '/pages/2005/6/12',
    url_for(rs, { :controller => 'content', :action => 'list_pages', :year => 2005, :month => 6, :day => 12 })

  assert_equal '/pages/2005/6/4',
    url_for(rs, { :day => 4 },   { :controller => 'content', :action => 'list_pages', :year => '2005', :month => '6', :day => '12' })

  assert_equal '/pages/2005/6',
    url_for(rs, { :day => nil }, { :controller => 'content', :action => 'list_pages', :year => '2005', :month => '6', :day => '12' })

  assert_equal '/pages/2005',
    url_for(rs, { :day => nil, :month => nil }, { :controller => 'content', :action => 'list_pages', :year => '2005', :month => '6', :day => '12' })
end

# File actionpack/test/controller/routing_test.rb, line 553
def test_should_list_options_diff_when_routing_constraints_dont_match
  rs.draw do
    match 'post/:id' => 'post#show', :constraints => { :id => /\d+/ }, :as => 'post'
  end
  assert_raise(ActionController::RoutingError) do
    url_for(rs, { :controller => 'post', :action => 'show', :bad_param => "foo", :use_route => "post" })
  end
end

# File actionpack/test/controller/routing_test.rb, line 282
def test_specific_controller_action_failure
  @rs.draw do
    mount lambda {} => "/foo"
  end

  assert_raises(ActionController::RoutingError) do
    url_for(@rs, :controller => "omg", :action => "lol")
  end
end

# File actionpack/test/controller/routing_test.rb, line 157
def test_star_paths_are_greedy
  rs.draw do
    match "/*path", :to => lambda { |env|
      x = env["action_dispatch.request.path_parameters"][:path]
      [200, {}, [x]]
    }, :format => false
  end

  u = URI('http://example.org/foo/bar.html')
  assert_equal u.path.sub(/^\//, ''), get(u)
end

# File actionpack/test/controller/routing_test.rb, line 169
def test_star_paths_are_greedy_but_not_too_much
  rs.draw do
    match "/*path", :to => lambda { |env|
      x = JSON.dump env["action_dispatch.request.path_parameters"]
      [200, {}, [x]]
    }
  end

  expected = { "path" => "foo/bar", "format" => "html" }
  u = URI('http://example.org/foo/bar.html')
  assert_equal expected, JSON.parse(get(u))
end

# File actionpack/test/controller/routing_test.rb, line 785
def test_subpath_generated
  rs.draw do
    match '/books/:id/edit'    => 'subpath_books#edit'
    match '/items/:id/:action' => 'subpath_books'
    match '/posts/new/:action' => 'subpath_books'
  end

  assert_equal "/books/7/edit",      url_for(rs, { :controller => "subpath_books", :id => 7, :action => "edit" })
  assert_equal "/items/15/complete", url_for(rs, { :controller => "subpath_books", :id => 15, :action => "complete" })
  assert_equal "/posts/new/preview", url_for(rs, { :controller => "subpath_books", :action => "preview" })
end

# File actionpack/test/controller/routing_test.rb, line 760
def test_subpath_recognized
  rs.draw do
    match '/books/:id/edit'    => 'subpath_books#edit'
    match '/items/:id/:action' => 'subpath_books'
    match '/posts/new/:action' => 'subpath_books'
    match '/posts/:id'         => 'subpath_books#show'
  end

  hash = rs.recognize_path "/books/17/edit"
  assert_not_nil hash
  assert_equal %w(subpath_books 17 edit), [hash[:controller], hash[:id], hash[:action]]

  hash = rs.recognize_path "/items/3/complete"
  assert_not_nil hash
  assert_equal %w(subpath_books 3 complete), [hash[:controller], hash[:id], hash[:action]]

  hash = rs.recognize_path "/posts/new/preview"
  assert_not_nil hash
  assert_equal %w(subpath_books preview), [hash[:controller], hash[:action]]

  hash = rs.recognize_path "/posts/7"
  assert_not_nil hash
  assert_equal %w(subpath_books show 7), [hash[:controller], hash[:action], hash[:id]]
end

# File actionpack/test/controller/routing_test.rb, line 95
def test_symbols_with_dashes
  rs.draw do
    match '/:artist/:song-omg', :to => lambda { |env|
      resp = JSON.dump env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
      [200, {}, [resp]]
    }
  end

  hash = JSON.load get(URI('http://example.org/journey/faithfully-omg'))
  assert_equal({"artist"=>"journey", "song"=>"faithfully"}, hash)
end

# File actionpack/test/controller/routing_test.rb, line 315
def test_time_recognition
  # We create many routes to make situation more realistic
  @rs = ::ActionDispatch::Routing::RouteSet.new
  @rs.draw {
    root :to => "search#new", :as => "frontpage"
    resources :videos do
      resources :comments
      resource  :file,      :controller => 'video_file'
      resource  :share,     :controller => 'video_shares'
      resource  :abuse,     :controller => 'video_abuses'
    end
    resources :abuses, :controller => 'video_abuses'
    resources :video_uploads
    resources :video_visits

    resources :users do
      resource  :settings
      resources :videos
    end
    resources :channels do
      resources :videos, :controller => 'channel_videos'
    end
    resource  :session
    resource  :lost_password
    match 'search' => 'search#index', :as => 'search'
    resources :pages
    match ':controller/:action/:id'
  }
end