jets 1.4.11 → 1.5.0

data/vendor/rails/actionpack/test/controller/url_for_integration_test.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "controller/fake_controllers"
+require "active_support/core_ext/object/with_options"
+
+module ActionPack
+  class URLForIntegrationTest < ActiveSupport::TestCase
+    include RoutingTestHelpers
+    include ActionDispatch::RoutingVerbs
+
+    Model = Struct.new(:to_param)
+
+    Mapping = lambda {
+      namespace :admin do
+        resources :users, :posts
+      end
+
+      namespace "api" do
+        root to: "users#index"
+      end
+
+      get "/blog(/:year(/:month(/:day)))" => "posts#show_date",
+        :constraints => {
+          year: /(19|20)\d\d/,
+          month: /[01]?\d/,
+          day: /[0-3]?\d/
+        },
+        :day => nil,
+        :month => nil
+
+      get "archive/:year", controller: "archive", action: "index",
+        defaults: { year: nil },
+        constraints: { year: /\d{4}/ },
+        as: "blog"
+
+      resources :people
+
+      get "symbols", controller: :symbols, action: :show, name: :as_symbol
+      get "id_default(/:id)" => "foo#id_default", :id => 1
+      match "get_or_post" => "foo#get_or_post", :via => [:get, :post]
+      get "optional/:optional" => "posts#index"
+      get "projects/:project_id" => "project#index", :as => "project"
+      get "clients" => "projects#index"
+
+      get "ignorecase/geocode/:postalcode" => "geocode#show", :postalcode => /hx\d\d-\d[a-z]{2}/i
+      get "extended/geocode/:postalcode" => "geocode#show", :constraints => {
+        postalcode: /# Postcode format
+        \d{5} #Prefix
+        (-\d{4})? #Suffix
+        /x
+      }, :as => "geocode"
+
+      get "news(.:format)" => "news#index"
+
+      ActiveSupport::Deprecation.silence {
+        get "comment/:id(/:action)" => "comments#show"
+        get "ws/:controller(/:action(/:id))", ws: true
+        get "account(/:action)" => "account#subscription"
+        get "pages/:page_id/:controller(/:action(/:id))"
+        get ":controller/ping", action: "ping"
+        get ":controller(/:action(/:id))(.:format)"
+      }
+
+      root to: "news#index"
+    }
+
+    attr_reader :routes
+    attr_accessor :controller
+
+    def setup
+      @routes = make_set false
+      @routes.draw(&Mapping)
+    end
+
+    [
+      ["/admin/users", [ { use_route: "admin_users" }]],
+      ["/admin/users", [ { controller: "admin/users" }]],
+      ["/admin/users", [ { controller: "admin/users", action: "index" }]],
+      ["/admin/users", [ { action: "index" }, { controller: "admin/users", action: "index" }, "/admin/users"]],
+      ["/admin/users", [ { controller: "users", action: "index" }, { controller: "admin/accounts", action: "show", id: "1" }, "/admin/accounts/show/1"]],
+      ["/people", [      { controller: "/people", action: "index" }, { controller: "admin/accounts", action: "foo", id: "bar" }, "/admin/accounts/foo/bar"]],
+
+      ["/admin/posts", [     { controller: "admin/posts" }]],
+      ["/admin/posts/new", [ { controller: "admin/posts", action: "new" }]],
+
+      ["/blog/2009", [     { controller: "posts", action: "show_date", year: 2009 }]],
+      ["/blog/2009/1", [   { controller: "posts", action: "show_date", year: 2009, month: 1 }]],
+      ["/blog/2009/1/1", [ { controller: "posts", action: "show_date", year: 2009, month: 1, day: 1 }]],
+
+      ["/archive/2010", [ { controller: "archive", action: "index", year: "2010" }]],
+      ["/archive", [      { controller: "archive", action: "index" }]],
+      ["/archive?year=january", [ { controller: "archive", action: "index", year: "january" }]],
+
+      ["/people", [ { controller: "people", action: "index" }]],
+      ["/people", [ { action: "index" }, { controller: "people", action: "index" }, "/people"]],
+      ["/people", [ { action: "index" }, { controller: "people", action: "show", id: "1" }, "/people/show/1"]],
+      ["/people", [ { controller: "people", action: "index" }, { controller: "people", action: "show", id: "1" }, "/people/show/1"]],
+      ["/people", [ {}, { controller: "people", action: "index" }, "/people"]],
+      ["/people/1", [   { controller: "people", action: "show" }, { controller: "people", action: "show", id: "1" }, "/people/show/1"]],
+      ["/people/new", [ { use_route: "new_person" }]],
+      ["/people/new", [ { controller: "people", action: "new" }]],
+      ["/people/1", [   { use_route: "person", id: "1" }]],
+      ["/people/1", [   { controller: "people", action: "show", id: "1" }]],
+      ["/people/1.xml", [ { controller: "people", action: "show", id: "1", format: "xml" }]],
+      ["/people/1", [ { controller: "people", action: "show", id: 1 }]],
+      ["/people/1", [ { controller: "people", action: "show", id: Model.new("1") }]],
+      ["/people/1", [ { action: "show", id: "1" }, { controller: "people", action: "index" }, "/people"]],
+      ["/people/1", [ { action: "show", id: 1 }, { controller: "people", action: "show", id: "1" }, "/people/show/1"]],
+      ["/people", [   { controller: "people", action: "index" }, { controller: "people", action: "show", id: "1" }, "/people/show/1"]],
+      ["/people/1", [ {}, { controller: "people", action: "show", id: "1" }, "/people/show/1"]],
+      ["/people/1", [ { controller: "people", action: "show" }, { controller: "people", action: "index", id: "1" }, "/people/index/1"]],
+      ["/people/1/edit", [     { controller: "people", action: "edit", id: "1" }]],
+      ["/people/1/edit.xml", [ { controller: "people", action: "edit", id: "1", format: "xml" }]],
+      ["/people/1/edit", [     { use_route: "edit_person", id: "1" }]],
+      ["/people/1?legacy=true", [ { controller: "people", action: "show", id: "1", legacy: "true" }]],
+      ["/people?legacy=true", [   { controller: "people", action: "index", legacy: "true" }]],
+
+      ["/id_default/2", [ { controller: "foo", action: "id_default", id: "2" }]],
+      ["/id_default", [   { controller: "foo", action: "id_default", id: "1" }]],
+      ["/id_default", [   { controller: "foo", action: "id_default", id: 1 }]],
+      ["/id_default", [   { controller: "foo", action: "id_default" }]],
+      ["/optional/bar", [ { controller: "posts", action: "index", optional: "bar" }]],
+      ["/posts", [ { controller: "posts", action: "index" }]],
+
+      ["/project", [    { controller: "project", action: "index" }]],
+      ["/projects/1", [ { controller: "project", action: "index", project_id: "1" }]],
+      ["/projects/1", [ { controller: "project", action: "index" }, { project_id: "1", controller: "project", action: "index" }, "/projects/1"]],
+      ["/projects/1", [ { use_route: "project", controller: "project", action: "index", project_id: "1" }]],
+      ["/projects/1", [ { use_route: "project", controller: "project", action: "index" }, { controller: "project", action: "index", project_id: "1" }, "/projects/1"]],
+
+      ["/clients", [ { controller: "projects", action: "index" }]],
+      ["/clients?project_id=1", [ { controller: "projects", action: "index", project_id: "1" }]],
+      ["/clients", [ { controller: "projects", action: "index" }, { project_id: "1", controller: "project", action: "index" }, "/projects/1"]],
+
+      ["/comment/20", [   { id: 20 }, { controller: "comments", action: "show" }, "/comments/show"]],
+      ["/comment/20", [   { controller: "comments", id: 20, action: "show" }]],
+      ["/comments/boo", [ { controller: "comments", action: "boo" }]],
+
+      ["/ws/posts/show/1", [ { controller: "posts", action: "show", id: "1", ws: true }]],
+      ["/ws/posts", [        { controller: "posts", action: "index", ws: true }]],
+
+      ["/account", [         { controller: "account", action: "subscription" }]],
+      ["/account/billing", [ { controller: "account", action: "billing" }]],
+
+      ["/pages/1/notes/show/1", [ { page_id: "1", controller: "notes", action: "show", id: "1" }]],
+      ["/pages/1/notes/list", [   { page_id: "1", controller: "notes", action: "list" }]],
+      ["/pages/1/notes", [ { page_id: "1", controller: "notes", action: "index" }]],
+      ["/pages/1/notes", [ { page_id: "1", controller: "notes" }]],
+      ["/notes", [         { page_id: nil, controller: "notes" }]],
+      ["/notes", [         { controller: "notes" }]],
+      ["/notes/print", [   { controller: "notes", action: "print" }]],
+      ["/notes/print", [   {}, { controller: "notes", action: "print" }, "/notes/print"]],
+
+      ["/notes/index/1", [ { controller: "notes" }, { controller: "notes", action: "index", id: "1" }, "/notes/index/1"]],
+      ["/notes/index/1", [ { controller: "notes" }, { controller: "notes", id: "1", action: "index" }, "/notes/index/1"]],
+      ["/notes/index/1", [ { action: "index" }, { controller: "notes", id: "1", action: "index" }, "/notes/index/1"]],
+      ["/notes/index/1", [ {}, { controller: "notes", id: "1", action: "index" }, "/notes/index/1"]],
+      ["/notes/show/1", [  {}, { controller: "notes", action: "show", id: "1" }, "/notes/show/1"]],
+      ["/posts", [      { controller: "posts" }, { controller: "notes", action: "show", id: "1" }, "/notes/show/1"]],
+      ["/notes/list", [ { action: "list" }, { controller: "notes", action: "show", id: "1" }, "/notes/show/1"]],
+
+      ["/posts/ping", [    { controller: "posts", action: "ping" }]],
+      ["/posts/show/1", [  { controller: "posts", action: "show", id: "1" }]],
+      ["/posts/show/1", [  { controller: "posts", action: "show", id: "1", format: "" }]],
+      ["/posts", [         { controller: "posts" }]],
+      ["/posts", [         { controller: "posts", action: "index" }]],
+      ["/posts/create", [  { action: "create" }, { day: nil, month: nil, controller: "posts", action: "show_date" }, "/blog"]],
+      ["/posts?foo=bar", [ { controller: "posts", foo: "bar" }]],
+      ["/posts?foo%5B%5D=bar&foo%5B%5D=baz", [{ controller: "posts", foo: ["bar", "baz"] }]],
+      ["/posts?page=2",  [{ controller: "posts", page: 2 }]],
+      ["/posts?q%5Bfoo%5D%5Ba%5D=b", [{ controller: "posts", q: { foo: { a: "b" } } }]],
+
+      ["/news.rss", [{ controller: "news", action: "index", format: "rss" }]],
+    ].each_with_index do |(url, params), i|
+      if params.length > 1
+        hash, path_params, route = *params
+        hash[:only_path] = true
+
+        define_method("test_#{url.gsub(/\W/, '_')}_#{i}") do
+          get URI("http://test.host" + route.to_s)
+          assert_equal path_params, controller.request.path_parameters
+          assert_equal url, controller.url_for(hash), params.inspect
+        end
+      else
+        define_method("test_#{url.gsub(/\W/, '_')}_#{i}") do
+          assert_equal url, url_for(@routes, params.first), params.inspect
+        end
+      end
+    end
+  end
+end

data/vendor/rails/actionpack/test/controller/url_for_test.rb

@@ -0,0 +1,519 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module AbstractController
+  module Testing
+    class UrlForTest < ActionController::TestCase
+      class W
+        include ActionDispatch::Routing::RouteSet.new.tap { |r|
+          r.draw {
+            ActiveSupport::Deprecation.silence {
+              get ":controller(/:action(/:id(.:format)))"
+            }
+          }
+        }.url_helpers
+      end
+
+      def teardown
+        W.default_url_options.clear
+      end
+
+      def test_nested_optional
+        klass = Class.new {
+          include ActionDispatch::Routing::RouteSet.new.tap { |r|
+            r.draw {
+              get "/foo/(:bar/(:baz))/:zot", as: "fun",
+                                             controller: :articles,
+                                             action: :index
+            }
+          }.url_helpers
+          default_url_options[:host] = "example.com"
+        }
+
+        path = klass.new.fun_path(controller: :articles,
+                                   baz: "baz",
+                                   zot: "zot")
+        # :bar key isn't provided
+        assert_equal "/foo/zot", path
+      end
+
+      def add_host!(app = W)
+        app.default_url_options[:host] = "www.basecamphq.com"
+      end
+
+      def add_port!
+        W.default_url_options[:port] = 3000
+      end
+
+      def add_numeric_host!
+        W.default_url_options[:host] = "127.0.0.1"
+      end
+
+      def test_exception_is_thrown_without_host
+        assert_raise ArgumentError do
+          W.new.url_for controller: "c", action: "a", id: "i"
+        end
+      end
+
+      def test_anchor
+        assert_equal("/c/a#anchor",
+          W.new.url_for(only_path: true, controller: "c", action: "a", anchor: "anchor")
+        )
+      end
+
+      def test_nil_anchor
+        assert_equal(
+          "/c/a",
+          W.new.url_for(only_path: true, controller: "c", action: "a", anchor: nil)
+        )
+      end
+
+      def test_false_anchor
+        assert_equal(
+          "/c/a",
+          W.new.url_for(only_path: true, controller: "c", action: "a", anchor: false)
+        )
+      end
+
+      def test_anchor_should_call_to_param
+        assert_equal("/c/a#anchor",
+          W.new.url_for(only_path: true, controller: "c", action: "a", anchor: Struct.new(:to_param).new("anchor"))
+        )
+      end
+
+      def test_anchor_should_escape_unsafe_pchar
+        assert_equal("/c/a#%23anchor",
+          W.new.url_for(only_path: true, controller: "c", action: "a", anchor: Struct.new(:to_param).new("#anchor"))
+        )
+      end
+
+      def test_anchor_should_not_escape_safe_pchar
+        assert_equal("/c/a#name=user&email=user@domain.com",
+          W.new.url_for(only_path: true, controller: "c", action: "a", anchor: Struct.new(:to_param).new("name=user&email=user@domain.com"))
+        )
+      end
+
+      def test_default_host
+        add_host!
+        assert_equal("http://www.basecamphq.com/c/a/i",
+          W.new.url_for(controller: "c", action: "a", id: "i")
+        )
+      end
+
+      def test_host_may_be_overridden
+        add_host!
+        assert_equal("http://37signals.basecamphq.com/c/a/i",
+          W.new.url_for(host: "37signals.basecamphq.com", controller: "c", action: "a", id: "i")
+        )
+      end
+
+      def test_subdomain_may_be_changed
+        add_host!
+        assert_equal("http://api.basecamphq.com/c/a/i",
+          W.new.url_for(subdomain: "api", controller: "c", action: "a", id: "i")
+        )
+      end
+
+      def test_subdomain_may_be_object
+        model = Class.new { def self.to_param; "api"; end }
+        add_host!
+        assert_equal("http://api.basecamphq.com/c/a/i",
+          W.new.url_for(subdomain: model, controller: "c", action: "a", id: "i")
+        )
+      end
+
+      def test_subdomain_may_be_removed
+        add_host!
+        assert_equal("http://basecamphq.com/c/a/i",
+          W.new.url_for(subdomain: false, controller: "c", action: "a", id: "i")
+        )
+      end
+
+      def test_subdomain_may_be_removed_with_blank_string
+        W.default_url_options[:host] = "api.basecamphq.com"
+        assert_equal("http://basecamphq.com/c/a/i",
+          W.new.url_for(subdomain: "", controller: "c", action: "a", id: "i")
+        )
+      end
+
+      def test_multiple_subdomains_may_be_removed
+        W.default_url_options[:host] = "mobile.www.api.basecamphq.com"
+        assert_equal("http://basecamphq.com/c/a/i",
+          W.new.url_for(subdomain: false, controller: "c", action: "a", id: "i")
+        )
+      end
+
+      def test_subdomain_may_be_accepted_with_numeric_host
+        add_numeric_host!
+        assert_equal("http://127.0.0.1/c/a/i",
+          W.new.url_for(subdomain: "api", controller: "c", action: "a", id: "i")
+        )
+      end
+
+      def test_domain_may_be_changed
+        add_host!
+        assert_equal("http://www.37signals.com/c/a/i",
+          W.new.url_for(domain: "37signals.com", controller: "c", action: "a", id: "i")
+        )
+      end
+
+      def test_tld_length_may_be_changed
+        add_host!
+        assert_equal("http://mobile.www.basecamphq.com/c/a/i",
+          W.new.url_for(subdomain: "mobile", tld_length: 2, controller: "c", action: "a", id: "i")
+        )
+      end
+
+      def test_port
+        add_host!
+        assert_equal("http://www.basecamphq.com:3000/c/a/i",
+          W.new.url_for(controller: "c", action: "a", id: "i", port: 3000)
+        )
+      end
+
+      def test_default_port
+        add_host!
+        add_port!
+        assert_equal("http://www.basecamphq.com:3000/c/a/i",
+          W.new.url_for(controller: "c", action: "a", id: "i")
+        )
+      end
+
+      def test_protocol
+        add_host!
+        assert_equal("https://www.basecamphq.com/c/a/i",
+          W.new.url_for(controller: "c", action: "a", id: "i", protocol: "https")
+        )
+      end
+
+      def test_protocol_with_and_without_separators
+        add_host!
+        assert_equal("https://www.basecamphq.com/c/a/i",
+          W.new.url_for(controller: "c", action: "a", id: "i", protocol: "https")
+        )
+        assert_equal("https://www.basecamphq.com/c/a/i",
+          W.new.url_for(controller: "c", action: "a", id: "i", protocol: "https:")
+        )
+        assert_equal("https://www.basecamphq.com/c/a/i",
+          W.new.url_for(controller: "c", action: "a", id: "i", protocol: "https://")
+        )
+      end
+
+      def test_without_protocol
+        add_host!
+        assert_equal("//www.basecamphq.com/c/a/i",
+          W.new.url_for(controller: "c", action: "a", id: "i", protocol: "//")
+        )
+        assert_equal("//www.basecamphq.com/c/a/i",
+          W.new.url_for(controller: "c", action: "a", id: "i", protocol: false)
+        )
+      end
+
+      def test_without_protocol_and_with_port
+        add_host!
+        add_port!
+
+        assert_equal("//www.basecamphq.com:3000/c/a/i",
+          W.new.url_for(controller: "c", action: "a", id: "i", protocol: "//")
+        )
+        assert_equal("//www.basecamphq.com:3000/c/a/i",
+          W.new.url_for(controller: "c", action: "a", id: "i", protocol: false)
+        )
+      end
+
+      def test_trailing_slash
+        add_host!
+        options = { controller: "foo", trailing_slash: true, action: "bar", id: "33" }
+        assert_equal("http://www.basecamphq.com/foo/bar/33/", W.new.url_for(options))
+      end
+
+      def test_trailing_slash_with_protocol
+        add_host!
+        options = { trailing_slash: true, protocol: "https", controller: "foo", action: "bar", id: "33" }
+        assert_equal("https://www.basecamphq.com/foo/bar/33/", W.new.url_for(options))
+        assert_equal "https://www.basecamphq.com/foo/bar/33/?query=string", W.new.url_for(options.merge(query: "string"))
+      end
+
+      def test_trailing_slash_with_only_path
+        options = { controller: "foo", trailing_slash: true }
+        assert_equal "/foo/", W.new.url_for(options.merge(only_path: true))
+        options.update(action: "bar", id: "33")
+        assert_equal "/foo/bar/33/", W.new.url_for(options.merge(only_path: true))
+        assert_equal "/foo/bar/33/?query=string", W.new.url_for(options.merge(query: "string", only_path: true))
+      end
+
+      def test_trailing_slash_with_anchor
+        options = { trailing_slash: true, controller: "foo", action: "bar", id: "33", only_path: true, anchor: "chapter7" }
+        assert_equal "/foo/bar/33/#chapter7", W.new.url_for(options)
+        assert_equal "/foo/bar/33/?query=string#chapter7", W.new.url_for(options.merge(query: "string"))
+      end
+
+      def test_trailing_slash_with_params
+        url = W.new.url_for(trailing_slash: true, only_path: true, controller: "cont", action: "act", p1: "cafe", p2: "link")
+        params = extract_params(url)
+        assert_equal({ p1: "cafe" }.to_query, params[0])
+        assert_equal({ p2: "link" }.to_query, params[1])
+      end
+
+      def test_relative_url_root_is_respected
+        add_host!
+        assert_equal("https://www.basecamphq.com/subdir/c/a/i",
+          W.new.url_for(controller: "c", action: "a", id: "i", protocol: "https", script_name: "/subdir")
+        )
+      end
+
+      def test_relative_url_root_is_respected_with_environment_variable
+        # `config.relative_url_root` is set by ENV['RAILS_RELATIVE_URL_ROOT']
+        w = Class.new {
+          config = ActionDispatch::Routing::RouteSet::Config.new "/subdir"
+          r = ActionDispatch::Routing::RouteSet.new(config)
+          r.draw { ActiveSupport::Deprecation.silence { get ":controller(/:action(/:id(.:format)))" } }
+          include r.url_helpers
+        }
+        add_host!(w)
+        assert_equal("https://www.basecamphq.com/subdir/c/a/i",
+          w.new.url_for(controller: "c", action: "a", id: "i", protocol: "https")
+        )
+      end
+
+      def test_named_routes
+        with_routing do |set|
+          set.draw do
+            get "this/is/verbose", to: "home#index", as: :no_args
+            get "home/sweet/home/:user", to: "home#index", as: :home
+          end
+
+          # We need to create a new class in order to install the new named route.
+          kls = Class.new { include set.url_helpers }
+
+          controller = kls.new
+          assert_respond_to controller, :home_url
+          assert_equal "http://www.basecamphq.com/home/sweet/home/again",
+            controller.send(:home_url, host: "www.basecamphq.com", user: "again")
+
+          assert_equal("/home/sweet/home/alabama", controller.send(:home_path, user: "alabama", host: "unused"))
+          assert_equal("http://www.basecamphq.com/home/sweet/home/alabama", controller.send(:home_url, user: "alabama", host: "www.basecamphq.com"))
+          assert_equal("http://www.basecamphq.com/this/is/verbose", controller.send(:no_args_url, host: "www.basecamphq.com"))
+        end
+      end
+
+      def test_relative_url_root_is_respected_for_named_routes
+        with_routing do |set|
+          set.draw do
+            get "/home/sweet/home/:user", to: "home#index", as: :home
+          end
+
+          kls = Class.new { include set.url_helpers }
+          controller = kls.new
+
+          assert_equal "http://www.basecamphq.com/subdir/home/sweet/home/again",
+            controller.send(:home_url, host: "www.basecamphq.com", user: "again", script_name: "/subdir")
+        end
+      end
+
+      def test_using_nil_script_name_properly_concats_with_original_script_name
+        add_host!
+        assert_equal("https://www.basecamphq.com/subdir/c/a/i",
+          W.new.url_for(controller: "c", action: "a", id: "i", protocol: "https", script_name: nil, original_script_name: "/subdir")
+        )
+      end
+
+      def test_only_path
+        with_routing do |set|
+          set.draw do
+            get "home/sweet/home/:user", to: "home#index", as: :home
+
+            ActiveSupport::Deprecation.silence do
+              get ":controller/:action/:id"
+            end
+          end
+
+          # We need to create a new class in order to install the new named route.
+          kls = Class.new { include set.url_helpers }
+          controller = kls.new
+          assert_respond_to controller, :home_url
+          assert_equal "/brave/new/world",
+            controller.url_for(controller: "brave", action: "new", id: "world", only_path: true)
+
+          assert_equal("/home/sweet/home/alabama", controller.home_path(user: "alabama", host: "unused"))
+          assert_equal("/home/sweet/home/alabama", controller.home_path("alabama"))
+        end
+      end
+
+      def test_one_parameter
+        assert_equal("/c/a?param=val",
+          W.new.url_for(only_path: true, controller: "c", action: "a", param: "val")
+        )
+      end
+
+      def test_two_parameters
+        url = W.new.url_for(only_path: true, controller: "c", action: "a", p1: "X1", p2: "Y2")
+        params = extract_params(url)
+        assert_equal({ p1: "X1" }.to_query, params[0])
+        assert_equal({ p2: "Y2" }.to_query, params[1])
+      end
+
+      def test_hash_parameter
+        url = W.new.url_for(only_path: true, controller: "c", action: "a", query: { name: "Bob", category: "prof" })
+        params = extract_params(url)
+        assert_equal({ "query[category]" => "prof" }.to_query, params[0])
+        assert_equal({ "query[name]" => "Bob" }.to_query, params[1])
+      end
+
+      def test_array_parameter
+        url = W.new.url_for(only_path: true, controller: "c", action: "a", query: ["Bob", "prof"])
+        params = extract_params(url)
+        assert_equal({ "query[]" => "Bob" }.to_query, params[0])
+        assert_equal({ "query[]" => "prof" }.to_query, params[1])
+      end
+
+      def test_hash_recursive_parameters
+        url = W.new.url_for(only_path: true, controller: "c", action: "a", query: { person: { name: "Bob", position: "prof" }, hobby: "piercing" })
+        params = extract_params(url)
+        assert_equal({ "query[hobby]"            => "piercing" }.to_query, params[0])
+        assert_equal({ "query[person][name]"     => "Bob"     }.to_query, params[1])
+        assert_equal({ "query[person][position]" => "prof"    }.to_query, params[2])
+      end
+
+      def test_hash_recursive_and_array_parameters
+        url = W.new.url_for(only_path: true, controller: "c", action: "a", id: 101, query: { person: { name: "Bob", position: ["prof", "art director"] }, hobby: "piercing" })
+        assert_match(%r(^/c/a/101), url)
+        params = extract_params(url)
+        assert_equal({ "query[hobby]"              => "piercing"    }.to_query, params[0])
+        assert_equal({ "query[person][name]"       => "Bob"         }.to_query, params[1])
+        assert_equal({ "query[person][position][]" => "art director" }.to_query, params[2])
+        assert_equal({ "query[person][position][]" => "prof"        }.to_query, params[3])
+      end
+
+      def test_url_action_controller_parameters
+        add_host!
+        assert_raise(ActionController::UnfilteredParameters) do
+          W.new.url_for(ActionController::Parameters.new(controller: "c", action: "a", protocol: "javascript", f: "%0Aeval(name)"))
+        end
+      end
+
+      def test_path_generation_for_symbol_parameter_keys
+        assert_generates("/image", controller: :image)
+      end
+
+      def test_named_routes_with_nil_keys
+        with_routing do |set|
+          set.draw do
+            get "posts.:format", to: "posts#index", as: :posts
+            get "/", to: "posts#index", as: :main
+          end
+
+          # We need to create a new class in order to install the new named route.
+          kls = Class.new { include set.url_helpers }
+          kls.default_url_options[:host] = "www.basecamphq.com"
+
+          controller = kls.new
+          params = { action: :index, controller: :posts, format: :xml }
+          assert_equal("http://www.basecamphq.com/posts.xml", controller.send(:url_for, params))
+          params[:format] = nil
+          assert_equal("http://www.basecamphq.com/", controller.send(:url_for, params))
+        end
+      end
+
+      def test_multiple_includes_maintain_distinct_options
+        first_class = Class.new { include ActionController::UrlFor }
+        second_class = Class.new { include ActionController::UrlFor }
+
+        first_host, second_host = "firsthost.com", "secondhost.com"
+
+        first_class.default_url_options[:host] = first_host
+        second_class.default_url_options[:host] = second_host
+
+        assert_equal first_host, first_class.default_url_options[:host]
+        assert_equal second_host, second_class.default_url_options[:host]
+      end
+
+      def test_with_stringified_keys
+        assert_equal("/c", W.new.url_for("controller" => "c", "only_path" => true))
+        assert_equal("/c/a", W.new.url_for("controller" => "c", "action" => "a", "only_path" => true))
+      end
+
+      def test_with_hash_with_indifferent_access
+        W.default_url_options[:controller] = "d"
+        W.default_url_options[:only_path]  = false
+        assert_equal("/c", W.new.url_for(ActiveSupport::HashWithIndifferentAccess.new("controller" => "c", "only_path" => true)))
+
+        W.default_url_options[:action] = "b"
+        assert_equal("/c/a", W.new.url_for(ActiveSupport::HashWithIndifferentAccess.new("controller" => "c", "action" => "a", "only_path" => true)))
+      end
+
+      def test_url_params_with_nil_to_param_are_not_in_url
+        assert_equal("/c/a", W.new.url_for(only_path: true, controller: "c", action: "a", id: Struct.new(:to_param).new(nil)))
+      end
+
+      def test_false_url_params_are_included_in_query
+        assert_equal("/c/a?show=false", W.new.url_for(only_path: true, controller: "c", action: "a", show: false))
+      end
+
+      def test_url_generation_with_array_and_hash
+        with_routing do |set|
+          set.draw do
+            namespace :admin do
+              resources :posts
+            end
+          end
+
+          kls = Class.new { include set.url_helpers }
+          kls.default_url_options[:host] = "www.basecamphq.com"
+
+          controller = kls.new
+          assert_equal("http://www.basecamphq.com/admin/posts/new?param=value",
+            controller.send(:url_for, [:new, :admin, :post, { param: "value" }])
+          )
+        end
+      end
+
+      def test_url_for_with_array_is_unmodified
+        with_routing do |set|
+          set.draw do
+            namespace :admin do
+              resources :posts
+            end
+          end
+
+          kls = Class.new { include set.url_helpers }
+          kls.default_url_options[:host] = "www.basecamphq.com"
+
+          original_components = [:new, :admin, :post, { param: "value" }]
+          components = original_components.dup
+
+          kls.new.url_for(components)
+
+          assert_equal(original_components, components)
+        end
+      end
+
+      def test_default_params_first_empty
+        with_routing do |set|
+          set.draw do
+            get "(:param1)/test(/:param2)" => "index#index",
+              defaults: {
+                param1: 1,
+                param2: 2
+              },
+              constraints: {
+                param1: /\d*/,
+                param2: /\d+/
+              }
+          end
+
+          kls = Class.new { include set.url_helpers }
+          kls.default_url_options[:host] = "www.basecamphq.com"
+
+          assert_equal "http://www.basecamphq.com/test", kls.new.url_for(controller: "index", param1: "1")
+        end
+      end
+
+      private
+        def extract_params(url)
+          url.split("?", 2).last.split("&").sort
+        end
+    end
+  end
+end