Class ActionDispatch::Journey::TestRouter < ActiveSupport::TestCase

# File actionpack/test/journey/router_test.rb, line 8
def setup
  @app       = Routing::RouteSet::Dispatcher.new({})
  @route_set  = ActionDispatch::Routing::RouteSet.new
  @routes = @route_set.router.routes
  @router = @route_set.router
  @formatter = @route_set.formatter
  @mapper = ActionDispatch::Routing::Mapper.new @route_set
end

# File actionpack/test/journey/router_test.rb, line 110
def test_X_Cascade
  get "/messages(.:format)", to: "foo#bar"
  resp = router.serve(rails_env({ 'REQUEST_METHOD' => 'GET', 'PATH_INFO' => '/lol' }))
  assert_equal ['Not Found'], resp.last
  assert_equal 'pass', resp[1]['X-Cascade']
  assert_equal 404, resp.first
end

# File actionpack/test/journey/router_test.rb, line 153
def test_bound_regexp_keeps_path_info
  get "/foo", to: "foo#bar"

  env = rails_env 'PATH_INFO' => '/foo'

  before = env.env['SCRIPT_NAME']

  router.recognize(env) { |*_| }

  assert_equal before, env.env['SCRIPT_NAME']
  assert_equal '/foo', env.env['PATH_INFO']
end

# File actionpack/test/journey/router_test.rb, line 118
def test_clear_trailing_slash_from_script_name_on_root_unanchored_routes
  app    = lambda { |env| [200, {}, ['success!']] }
  get '/weblog', :to => app

  env  = rack_env('SCRIPT_NAME' => '', 'PATH_INFO' => '/weblog')
  resp = route_set.call env
  assert_equal ['success!'], resp.last
  assert_equal '', env['SCRIPT_NAME']
end

# File actionpack/test/journey/router_test.rb, line 17
def test_dashes
  get '/foo-bar-baz', to: 'foo#bar'

  env = rails_env 'PATH_INFO' => '/foo-bar-baz'
  called = false
  router.recognize(env) do |r, params|
    called = true
  end
  assert called
end

# File actionpack/test/journey/router_test.rb, line 128
def test_defaults_merge_correctly
  get '/foo(/:id)', to: "foo#bar", id: nil

  env = rails_env 'PATH_INFO' => '/foo/10'
  router.recognize(env) do |r, params|
    assert_equal({:id => '10', :controller => "foo", :action => "bar"}, params)
  end

  env = rails_env 'PATH_INFO' => '/foo'
  router.recognize(env) do |r, params|
    assert_equal({:id => nil, :controller => "foo", :action => "bar"}, params)
  end
end

# File actionpack/test/journey/router_test.rb, line 100
def test_does_not_include_missing_keys_message
  route_name = "gorby_thunderhorse"

  error = assert_raises(ActionController::UrlGenerationError) do
    @formatter.generate(route_name, { }, { })
  end

  assert_no_match(/missing required keys: \[\]/, error.message)
end

# File actionpack/test/journey/router_test.rb, line 225
def test_generate_calls_param_proc
  get '/:controller(/:action)', to: "foo#bar"

  parameterized = []
  params = [ [:controller, "tasks"],
             [:action, "show"] ]

  @formatter.generate(
    nil,
    Hash[params],
    {},
    lambda { |k,v| parameterized << [k,v]; v })

  assert_equal params.map(&:to_s).sort, parameterized.map(&:to_s).sort
end

# File actionpack/test/journey/router_test.rb, line 250
def test_generate_escapes
  get '/:controller(/:action)', to: "foo#bar"

  path, _ = @formatter.generate(nil,
    { :controller        => "tasks",
           :action            => "a/b c+d",
  }, {})
  assert_equal '/tasks/a%2Fb%20c+d', path
end

# File actionpack/test/journey/router_test.rb, line 260
def test_generate_escapes_with_namespaced_controller
  get '/:controller(/:action)', to: "foo#bar"

  path, _ = @formatter.generate(
    nil, { :controller        => "admin/tasks",
           :action            => "a/b c+d",
  }, {})
  assert_equal '/admin/tasks/a%2Fb%20c+d', path
end

# File actionpack/test/journey/router_test.rb, line 270
def test_generate_extra_params
  get '/:controller(/:action)', to: "foo#bar"

  path, params = @formatter.generate(
    nil, { :id                => 1,
           :controller        => "tasks",
           :action            => "show",
           :relative_url_root => nil
  }, {})
  assert_equal '/tasks/show', path
  assert_equal({:id => 1, :relative_url_root => nil}, params)
end

# File actionpack/test/journey/router_test.rb, line 241
def test_generate_id
  get '/:controller(/:action)', to: 'foo#bar'

  path, params = @formatter.generate(
    nil, {:id=>1, :controller=>"tasks", :action=>"show"}, {})
  assert_equal '/tasks/show', path
  assert_equal({:id => 1}, params)
end

# File actionpack/test/journey/router_test.rb, line 283
def test_generate_missing_keys_no_matches_different_format_keys
  get '/:controller/:action/:name', to: "foo#bar"
  primarty_parameters = {
    :id                => 1,
    :controller        => "tasks",
    :action            => "show",
    :relative_url_root => nil
  }
  redirection_parameters = {
    'action'=>'show',
  }
  missing_key = 'name'
  missing_parameters ={
    missing_key => "task_1"
  }
  request_parameters = primarty_parameters.merge(redirection_parameters).merge(missing_parameters)

  message = "No route matches #{Hash[request_parameters.sort_by{|k,v|k.to_s}].inspect} missing required keys: #{[missing_key.to_sym].inspect}"

  error = assert_raises(ActionController::UrlGenerationError) do
    @formatter.generate(
      nil, request_parameters, request_parameters)
  end
  assert_equal message, error.message
end

# File actionpack/test/journey/router_test.rb, line 216
def test_generate_slash
  params = [ [:controller, "tasks"],
             [:action, "show"] ]
  get "/", Hash[params]

  path, _ = @formatter.generate(nil, Hash[params], {})
  assert_equal '/', path
end

# File actionpack/test/journey/router_test.rb, line 309
def test_generate_uses_recall_if_needed
  get '/:controller(/:action(/:id))', to: "foo#bar"

  path, params = @formatter.generate(
    nil,
    {:controller =>"tasks", :id => 10},
    {:action     =>"index"})
  assert_equal '/tasks/index/10', path
  assert_equal({}, params)
end

# File actionpack/test/journey/router_test.rb, line 320
def test_generate_with_name
  get '/:controller(/:action)', to: 'foo#bar', as: 'tasks'

  path, params = @formatter.generate(
    "tasks",
    {:controller=>"tasks"},
    {:controller=>"tasks", :action=>"index"})
  assert_equal '/tasks', path
  assert_equal({}, params)
end

# File actionpack/test/journey/router_test.rb, line 89
def test_knows_what_parts_are_missing_from_named_route
  route_name = "gorby_thunderhorse"
  get "/foo/:id", :as => route_name, :id => /\d+/, :to => "foo#bar"

  error = assert_raises(ActionController::UrlGenerationError) do
    @formatter.generate(route_name, { }, { })
  end

  assert_match(/missing required keys: \[:id\]/, error.message)
end

# File actionpack/test/journey/router_test.rb, line 468
def test_multi_verb_recognition
  match "/books(/:action(.:format))", to: "foo#bar", via: [:post, :get]

  %w( POST GET ).each do |verb|
    env = rails_env 'PATH_INFO' => '/books/list.rss',
      "REQUEST_METHOD" => verb

    called = false
    router.recognize(env) do |r, params|
      called = true
    end

    assert called
  end

  env = rails_env 'PATH_INFO' => '/books/list.rss',
    "REQUEST_METHOD" => 'PUT'

  called = false
  router.recognize(env) do |r, params|
    called = true
  end

  assert_not called
end

# File actionpack/test/journey/router_test.rb, line 374
def test_namespaced_controller
  get "/:controller(/:action(/:id))", { :controller => /.+?/ }
  route = @routes.first

  env = rails_env 'PATH_INFO' => '/admin/users/show/10'
  called   = false
  expected = {
    :controller => 'admin/users',
    :action     => 'show',
    :id         => '10'
  }

  router.recognize(env) do |r, params|
    assert_equal route, r
    assert_equal(expected, params)
    called = true
  end
  assert called
end

# File actionpack/test/journey/router_test.rb, line 206
def test_nil_path_parts_are_ignored
  get "/:controller(/:action(.:format))", to: "tasks#lol"

  params = { :controller => "tasks", :format => nil }
  extras = { :action => 'lol' }

  path, _ = @formatter.generate(nil, params, extras)
  assert_equal '/tasks', path
end

# File actionpack/test/journey/router_test.rb, line 76
def test_only_required_parts_are_verified
  get "/foo(/:id)", :id => /\d/, :to => "foo#bar"

  path, _ = @formatter.generate(nil, { :controller => "foo", :action => "bar", :id => '10' }, { })
  assert_equal '/foo/10', path

  path, _ = @formatter.generate(nil, { :controller => "foo", :action => "bar" }, { })
  assert_equal '/foo', path

  path, _ = @formatter.generate(nil, { :controller => "foo", :action => "bar", :id => 'aa' }, { })
  assert_equal '/foo/aa', path
end

# File actionpack/test/journey/router_test.rb, line 166
def test_path_not_found
  [
    "/messages(.:format)",
    "/messages/new(.:format)",
    "/messages/:id/edit(.:format)",
    "/messages/:id(.:format)"
  ].each do |path|
    get path, to: "foo#bar"
  end
  env = rails_env 'PATH_INFO' => '/messages/unknown/path'
  yielded = false

  router.recognize(env) do |*whatever|
    yielded = true
  end
  assert_not yielded
end

# File actionpack/test/journey/router_test.rb, line 198
def test_recall_should_be_used_when_scoring
  get "/messages/:action(/:id(.:format))", to: 'foo#bar'
  get "/messages/:id(.:format)", to: 'bar#baz'

  path, _ = @formatter.generate(nil, { :controller => "foo", :id => 10 }, { :action => 'index' })
  assert_equal "/messages/index/10", path
end

# File actionpack/test/journey/router_test.rb, line 440
def test_recognize_cares_about_get_verbs
  match "/books(/:action(.:format))", to: "foo#bar", via: :get

  env = rails_env 'PATH_INFO' => '/books/list.rss',
                  "REQUEST_METHOD" => "POST"

  called = false
  router.recognize(env) do |r, params|
    called = true
  end

  assert_not called
end

# File actionpack/test/journey/router_test.rb, line 454
def test_recognize_cares_about_post_verbs
  match "/books(/:action(.:format))", to: "foo#bar", via: :post

  env = rails_env 'PATH_INFO' => '/books/list.rss',
                  "REQUEST_METHOD" => "POST"

  called = false
  router.recognize(env) do |r, params|
    called = true
  end

  assert called
end

# File actionpack/test/journey/router_test.rb, line 426
def test_recognize_head_request_as_get_route
  get "/books(/:action(.:format))", to: 'foo#bar'

  env = rails_env 'PATH_INFO' => '/books/list.rss',
                  "REQUEST_METHOD"    => "HEAD"

  called = false
  router.recognize(env) do |r, params|
    called = true
  end

  assert called
end

# File actionpack/test/journey/router_test.rb, line 410
def test_recognize_head_route
  match "/books(/:action(.:format))", via: 'head', to: 'foo#bar'

  env = rails_env(
    'PATH_INFO' => '/books/list.rss',
    'REQUEST_METHOD' => 'HEAD'
  )

  called = false
  router.recognize(env) do |r, params|
    called = true
  end

  assert called
end

# File actionpack/test/journey/router_test.rb, line 394
def test_recognize_literal
  get "/books(/:action(.:format))", controller: "books"
  route = @routes.first

  env    = rails_env 'PATH_INFO' => '/books/list.rss'
  expected = { :controller => 'books', :action => 'list', :format => 'rss' }
  called = false
  router.recognize(env) do |r, params|
    assert_equal route, r
    assert_equal(expected, params)
    called = true
  end

  assert called
end

# File actionpack/test/journey/router_test.rb, line 142
def test_recognize_with_unbound_regexp
  get "/foo", anchor: false, to: "foo#bar"

  env = rails_env 'PATH_INFO' => '/foo/bar'

  router.recognize(env) { |*_| }

  assert_equal '/foo', env.env['SCRIPT_NAME']
  assert_equal '/bar', env.env['PATH_INFO']
end

# File actionpack/test/journey/router_test.rb, line 40
def test_regexp_first_precedence
  get "/whois/:domain", :domain => /\w+\.[\w\.]+/, to: "foo#bar"
  get "/whois/:id(.:format)", to: "foo#baz"

  env = rails_env 'PATH_INFO' => '/whois/example.com'

  list = []
  router.recognize(env) do |r, params|
    list << r
  end
  assert_equal 2, list.length

  r = list.first

  assert_equal '/whois/:domain(.:format)', r.path.spec.to_s
end

# File actionpack/test/journey/router_test.rb, line 184
def test_required_part_in_recall
  get "/messages/:a/:b", to: "foo#bar"

  path, _ = @formatter.generate(nil, { :controller => "foo", :action => "bar", :a => 'a' }, { :b => 'b' })
  assert_equal "/messages/a/b", path
end

# File actionpack/test/journey/router_test.rb, line 65
def test_required_parts_are_verified_when_building
  get "/foo/:id", :id => /\d+/, anchor: false, to: "foo#bar"

  path, _ = @formatter.generate(nil, { :controller => "foo", :action => "bar", :id => '10' }, { })
  assert_equal '/foo/10', path

  assert_raises(ActionController::UrlGenerationError) do
    @formatter.generate(nil, { :id => 'aa' }, { })
  end
end

# File actionpack/test/journey/router_test.rb, line 57
def test_required_parts_verified_are_anchored
  get "/foo/:id", :id => /\d/, anchor: false, to: "foo#bar"

  assert_raises(ActionController::UrlGenerationError) do
    @formatter.generate(nil, { :controller => "foo", :action => "bar", :id => '10' }, { })
  end
end

# File actionpack/test/journey/router_test.rb, line 191
def test_splat_in_recall
  get "/*path", to: "foo#bar"

  path, _ = @formatter.generate(nil, { :controller => "foo", :action => "bar" }, { :path => 'b' })
  assert_equal "/b", path
end

# File actionpack/test/journey/router_test.rb, line 28
def test_unicode
  get '/ほげ', to: 'foo#bar'

  #match the escaped version of /ほげ
  env = rails_env 'PATH_INFO' => '/%E3%81%BB%E3%81%92'
  called = false
  router.recognize(env) do |r, params|
    called = true
  end
  assert called
end