require "abstract_unit" module ActionDispatch module Journey class TestRouter < ActiveSupport::TestCase attr_reader :mapper, :routes, :route_set, :router 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 def test_generate_slash params = [ [:controller, "tasks"], [:action, "show"] ] get "/", Hash[params] path, _ = @formatter.generate(nil, Hash[params], {}) assert_equal "/", path end 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 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 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 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 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 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 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 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 { "/content" => { controller: "content" }, "/content/list" => { controller: "content", action: "list" }, "/content/show/10" => { controller: "content", action: "show", id: "10" }, }.each do |request_path, expected| define_method("test_recognize_#{expected.keys.map(&:to_s).join('_')}") do get "/:controller(/:action(/:id))", to: "foo#bar" route = @routes.first env = rails_env "PATH_INFO" => request_path called = false router.recognize(env) do |r, params| assert_equal route, r assert_equal({ action: "bar" }.merge(expected), params) called = true end assert called end end { segment: ["/a%2Fb%20c+d/splat", { segment: "a/b c+d", splat: "splat" }], splat: ["/segment/a/b%20c+d", { segment: "segment", splat: "a/b c+d" }] }.each do |name, (request_path, expected)| define_method("test_recognize_#{name}") do get "/:segment/*splat", to: "foo#bar" env = rails_env "PATH_INFO" => request_path called = false route = @routes.first router.recognize(env) do |r, params| assert_equal route, r assert_equal(expected.merge(controller: "foo", action: "bar"), params) called = true end assert called end end 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 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 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 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 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 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 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 private def get(*args) ActiveSupport::Deprecation.silence do mapper.get(*args) end end def match(*args) ActiveSupport::Deprecation.silence do mapper.match(*args) end end def rails_env(env, klass = ActionDispatch::Request) klass.new(rack_env(env)) end def rack_env(env) { "rack.version" => [1, 1], "rack.input" => StringIO.new, "rack.errors" => StringIO.new, "rack.multithread" => true, "rack.multiprocess" => true, "rack.run_once" => false, "REQUEST_METHOD" => "GET", "SERVER_NAME" => "example.org", "SERVER_PORT" => "80", "QUERY_STRING" => "", "PATH_INFO" => "/content", "rack.url_scheme" => "http", "HTTPS" => "off", "SCRIPT_NAME" => "", "CONTENT_LENGTH" => "0" }.merge env end end end end