Class LegacyRouteSetTests < ActiveSupport::TestCase

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

# File actionpack/test/controller/routing_test.rb, line 82
def setup
  @rs = make_set
  @response = nil
end

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

# File actionpack/test/controller/routing_test.rb, line 791
def setup_request_method_routes_for(method)
  rs.draw do
    match '/match' => "books##{method}", :via => method.to_sym
  end
end

# File actionpack/test/controller/routing_test.rb, line 669
def test_action_expiry
  rs.draw { ActiveSupport::Deprecation.silence { get ':controller(/:action(/:id))' } }
  get URI('http://test.host/content/show')
  assert_equal '/content', controller.url_for(:controller => 'content', :only_path => true)
end

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

  get URI('http://test.host/pages/show')
  assert_equal '/page/20',   controller.url_for({ :id => 20, :only_path => true })
  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 401
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 687
def test_both_requirement_and_optional
  rs.draw do
    get('test(/:year)' => 'post#show', :as => 'blog',
      :defaults => { :year => nil },
      :constraints => { :year => /\d{4}/ }
    )

    ActiveSupport::Deprecation.silence do
      get ':controller/:action/:id'
    end
  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 537
def test_changing_controller
  rs.draw { ActiveSupport::Deprecation.silence { get ':controller/:action/:id' } }

  get URI('http://test.host/admin/user/index/10')

  assert_equal '/admin/stuff/show/10',
      controller.url_for({:controller => 'stuff', :action => 'show', :id => 10, :only_path => true})
end

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

  rs.draw do
    get '/', :constraints => subdomain.new,
               :to          => lambda { |env| [200, {}, %w{default}] }
    get '/', :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 111
def test_dash_with_custom_regexp
  rs.draw do
    get '/:artist/:song-omg', :constraints => { :song => /\d+/ }, :to => lambda { |env|
      resp = ActiveSupport::JSON.encode ActionDispatch::Request.new(env).path_parameters
      [200, {}, [resp]]
    }
  end

  hash = ActiveSupport::JSON.decode 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 304
def test_default_setup
  rs.draw { ActiveSupport::Deprecation.silence { get '/: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 })

  get URI('http://test.host/admin/user/list/10')

  assert_equal({ :controller => 'admin/user', :action => 'list', :id => '10' },
               controller.request.path_parameters)

  assert_equal '/admin/user/show',    controller.url_for({ :action => 'show', :only_path => true })
  assert_equal '/admin/user/list/10', controller.url_for({:only_path => true})

  assert_equal '/admin/stuff', controller.url_for({ :controller => 'stuff', :only_path => true })
  assert_equal '/stuff', controller.url_for({ :controller => '/stuff', :only_path => true })
end

# File actionpack/test/controller/routing_test.rb, line 593
def test_dynamic_path_allowed
  rs.draw do
    get '*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 602
def test_dynamic_recall_paths_allowed
  rs.draw do
    get '*path' => 'content#show_file'
  end

  get URI('http://test.host/pages/boo')
  assert_equal({:controller=>"content", :action=>"show_file", :path=>"pages/boo"},
               controller.request.path_parameters)

  assert_equal '/pages/boo',
    controller.url_for(:only_path => true)
end

# File actionpack/test/controller/routing_test.rb, line 272
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 859
def test_failed_constraints_raises_exception_with_violated_constraints
  rs.draw do
    get 'foos/:id' => 'foos#show', :as => 'foo_with_requirement', :constraints => { :id => /\d+/ }
  end

  assert_raise(ActionController::UrlGenerationError) 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 99
def test_id_with_dash
  rs.draw do
    get '/journey/:id', :to => lambda { |env|
      resp = ActiveSupport::JSON.encode ActionDispatch::Request.new(env).path_parameters
      [200, {}, [resp]]
    }
  end

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

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

    get '/', :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 744
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 755
def test_named_route_method
  rs.draw do
    get 'categories' => 'content#categories', :as => 'categories'

    ActiveSupport::Deprecation.silence do
      get ':controller(/:action(/:id))'
    end
  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 477
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 495
def test_named_route_root_with_hash
  rs.draw do
    root "hello#index", as: :index
  end

  routes = setup_for_named_route
  assert_equal("http://test.host/", routes.send(:index_url))
  assert_equal("/", routes.send(:index_path))
end

# File actionpack/test/controller/routing_test.rb, line 511
def test_named_route_root_with_trailing_slash
  rs.draw do
    root "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 486
def test_named_route_root_without_hash
  rs.draw do
    root "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 437
def test_named_route_with_blank_path_prefix
  rs.draw do
    scope "" do
      get '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 417
def test_named_route_with_default
  rs.draw do
    get '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 448
def test_named_route_with_nested_controller
  rs.draw do
    get '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 408
def test_named_route_with_option
  rs.draw do
    get '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 426
def test_named_route_with_path_prefix
  rs.draw do
    scope "my" do
      get '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 521
def test_named_route_with_regexps
  rs.draw do
    get 'page/:year/:month/:day/:title' => 'page#show', :as => 'article',
      :year => /\d+/, :month => /\d+/, :day => /\d+/

    ActiveSupport::Deprecation.silence do
      get ':controller/:action/:id'
    end
  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 469
def test_named_route_without_hash
  rs.draw do
    ActiveSupport::Deprecation.silence do
      get ':controller/:action/:id', :as => 'normal'
    end
  end
end

# File actionpack/test/controller/routing_test.rb, line 768
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 773
def test_nil_defaults
  rs.draw do
    get 'journal' => 'content#list_journal',
      :date => nil, :user_id => nil

    ActiveSupport::Deprecation.silence do
      get ':controller/:action/:id'
    end
  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 575
def test_non_controllers_cannot_be_matched
  rs.draw do
    ActiveSupport::Deprecation.silence do
      get ':controller/:action/:id'
    end
  end
  assert_raise(ActionController::RoutingError) { rs.recognize_path("/not_a/show/10") }
end

# File actionpack/test/controller/routing_test.rb, line 281
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 457
def test_optimised_named_route_with_host
  rs.draw do
    get 'page' => 'content#show_page', :as => 'pages', :host => 'foo.com'
  end
  routes = setup_for_named_route
  assert_equal "http://foo.com/page", routes.pages_url
end

# File actionpack/test/controller/routing_test.rb, line 174
def test_optional_star_paths_are_greedy
  rs.draw do
    get "/(*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 186
def test_optional_star_paths_are_greedy_but_not_too_much
  rs.draw do
    get "/(*filters)", :to => lambda { |env|
      x = ActiveSupport::JSON.encode 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, ActiveSupport::JSON.decode(get(u))
end

# File actionpack/test/controller/routing_test.rb, line 546
def test_paths_escaped
  rs.draw do
    get 'file/*path' => 'content#show_file', :as => 'path'

    ActiveSupport::Deprecation.silence do
      get ':controller/:action/:id'
    end
  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 566
def test_paths_slashes_unescaped_with_ordered_parameters
  rs.draw do
    get '/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 124
def test_pre_dash
  rs.draw do
    get '/:artist/omg-:song', :to => lambda { |env|
      resp = ActiveSupport::JSON.encode ActionDispatch::Request.new(env).path_parameters
      [200, {}, [resp]]
    }
  end

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

# File actionpack/test/controller/routing_test.rb, line 136
def test_pre_dash_with_custom_regexp
  rs.draw do
    get '/:artist/omg-:song', :constraints => { :song => /\d+/ }, :to => lambda { |env|
      resp = ActiveSupport::JSON.encode ActionDispatch::Request.new(env).path_parameters
      [200, {}, [resp]]
    }
  end

  hash = ActiveSupport::JSON.decode 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 805
def test_recognize_array_of_methods
  rs.draw do
    match '/match' => 'books#get_or_post', :via => [:get, :post]
    put '/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 200
def test_regexp_precidence
  rs.draw do
    get '/whois/:domain', :constraints => {
      :domain => /\w+\.[\w\.]+/ },
      :to     => lambda { |env| [200, {}, %w{regexp}] }

    get '/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 675
def test_requirement_should_prevent_optional_id
  rs.draw do
    get '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::UrlGenerationError) do
    url_for(rs, { :controller => 'post', :action => 'show' })
  end
end

# File actionpack/test/controller/routing_test.rb, line 735
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 505
def test_root_without_path_raises_argument_error
  assert_raises ArgumentError do
    rs.draw { root nil }
  end
end

# File actionpack/test/controller/routing_test.rb, line 326
def test_route_with_colon_first
  rs.draw do
    ActiveSupport::Deprecation.silence do
      get '/:controller/:action/:id', action: 'index', id: nil
    end

    get ':url', controller: 'content', action: 'translate'
  end

  assert_equal({controller: 'content', action: 'translate', url: 'example'}, rs.recognize_path('/example'))
end

# File actionpack/test/controller/routing_test.rb, line 629
def test_route_with_integer_default
  rs.draw do
    get 'page(/:id)' => 'content#show_page', :id => 1

    ActiveSupport::Deprecation.silence do
      get ':controller/:action/:id'
    end
  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 365
def test_route_with_regexp_and_captures_for_controller
  rs.draw do
    ActiveSupport::Deprecation.silence do
      get '/:controller(/:action(/:id))', :controller => /admin\/(accounts|users)/
    end
  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
    ActiveSupport::Deprecation.silence do
      get ':controller/:action/:file',
                :controller => /admin|user/,
                :action => /upload|download/,
                :defaults => {:file => nil},
                :constraints => {:file => %r{[^/]+(\.[^/]+)?}}
    end
  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 338
def test_route_with_regexp_for_action
  rs.draw { ActiveSupport::Deprecation.silence { get '/:controller/:action', action: /auth[-|_].+/ } }

  assert_equal({ action: 'auth_google', controller: 'content' }, rs.recognize_path('/content/auth_google'))
  assert_equal({ action: 'auth-facebook', controller: 'content' }, rs.recognize_path('/content/auth-facebook'))

  assert_equal '/content/auth_google', url_for(rs, { controller: "content", action: "auth_google" })
  assert_equal '/content/auth-facebook', url_for(rs, { controller: "content", action: "auth-facebook" })
end

# File actionpack/test/controller/routing_test.rb, line 348
def test_route_with_regexp_for_controller
  rs.draw do
    ActiveSupport::Deprecation.silence do
      get ':controller/:admintoken(/:action(/:id))', :controller => /admin\/.+/
      get '/:controller(/:action(/:id))'
    end
  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 649
def test_route_with_text_default
  rs.draw do
    get 'page/:id' => 'content#show_page', :id => 1

    ActiveSupport::Deprecation.silence do
      get ':controller/:action/:id'
    end
  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)
  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 869
def test_routes_changed_correctly_after_clear
  rs = ::ActionDispatch::Routing::RouteSet.new
  rs.draw do
    get 'ca' => 'ca#aa'
    get 'cb' => 'cb#ab'
    get 'cc' => 'cc#ac'

    ActiveSupport::Deprecation.silence do
      get ':controller/:action/:id'
      get ':controller/:action/:id.:format'
    end
  end

  hash = rs.recognize_path "/cc"

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

  rs.draw do
    get 'cb' => 'cb#ab'
    get 'cc' => 'cc#ac'

    ActiveSupport::Deprecation.silence do
      get ':controller/:action/:id'
      get ':controller/:action/:id.:format'
    end
  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 246
def test_scoped_lambda
  scope_called = false
  rs.draw do
    scope '/foo', :constraints => lambda { |req| scope_called = true } do
      get '/', :to => lambda { |env| [200, {}, %w{default}] }
    end
  end

  assert_equal 'default', get(URI('http://www.example.org/foo/'))
  assert scope_called, "scope constraint should be called"
end

# File actionpack/test/controller/routing_test.rb, line 258
def test_scoped_lambda_with_get_lambda
  inner_called = false

  rs.draw do
    scope '/foo', :constraints => lambda { |req| flunk "should not be called" } do
      get '/', :constraints    => lambda { |req| inner_called = true },
               :to             => lambda { |env| [200, {}, %w{default}] }
    end
  end

  assert_equal 'default', get(URI('http://www.example.org/foo/'))
  assert inner_called, "inner constraint should be called"
end

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

    ActiveSupport::Deprecation.silence do
      get ':controller/:action/:id'
    end
  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 })

  get URI('http://test.host/pages/2005/6/12')
  assert_equal({ :controller => 'content', :action => 'list_pages', :year => '2005', :month => '6', :day => '12' },
              controller.request.path_parameters)

  assert_equal '/pages/2005/6/4',
    controller.url_for({ :day => 4, :only_path => true })

  assert_equal '/pages/2005/6',
    controller.url_for({ :day => nil, :only_path => true })

  assert_equal '/pages/2005',
    controller.url_for({ :day => nil, :month => nil, :only_path => true })
end

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

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

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

# File actionpack/test/controller/routing_test.rb, line 149
def test_star_paths_are_greedy
  rs.draw do
    get "/*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 161
def test_star_paths_are_greedy_but_not_too_much
  rs.draw do
    get "/*path", :to => lambda { |env|
      x = ActiveSupport::JSON.encode 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, ActiveSupport::JSON.decode(get(u))
end

# File actionpack/test/controller/routing_test.rb, line 845
def test_subpath_generated
  rs.draw do
    ActiveSupport::Deprecation.silence do
      get '/books/:id/edit'    => 'subpath_books#edit'
      get '/items/:id/:action' => 'subpath_books'
      get '/posts/new/:action' => 'subpath_books'
    end
  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 818
def test_subpath_recognized
  rs.draw do
    ActiveSupport::Deprecation.silence do
      get '/books/:id/edit'    => 'subpath_books#edit'
      get '/items/:id/:action' => 'subpath_books'
      get '/posts/new/:action' => 'subpath_books'
      get '/posts/:id'         => 'subpath_books#show'
    end
  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 87
def test_symbols_with_dashes
  rs.draw do
    get '/:artist/:song-omg', :to => lambda { |env|
      resp = ActiveSupport::JSON.encode ActionDispatch::Request.new(env).path_parameters
      [200, {}, [resp]]
    }
  end

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