jets 1.4.11 → 1.5.0

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "action_dispatch/testing/integration"
+
+module ActionDispatch
+  class RunnerTest < ActiveSupport::TestCase
+    class MyRunner
+      include Integration::Runner
+
+      def initialize(session)
+        @integration_session = session
+      end
+
+      def hi; end
+    end
+
+    def test_respond_to?
+      runner = MyRunner.new(Class.new { def x; end }.new)
+      assert_respond_to runner, :hi
+      assert_respond_to runner, :x
+    end
+  end
+end

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

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module TestFileUtils
+  def file_name() File.basename(__FILE__) end
+  def file_path() __FILE__ end
+  def file_data() @data ||= File.open(file_path, "rb") { |f| f.read } end
+end
+
+class SendFileController < ActionController::Base
+  include TestFileUtils
+  include ActionController::Testing
+  layout "layouts/standard" # to make sure layouts don't interfere
+
+  before_action :file, only: :file_from_before_action
+
+  attr_writer :options
+  def options
+    @options ||= {}
+  end
+
+  def file
+    send_file(file_path, options)
+  end
+
+  def file_from_before_action
+    raise "No file sent from before action."
+  end
+
+  def test_send_file_headers_bang
+    options = {
+      type: Mime[:png],
+      disposition: "disposition",
+      filename: "filename"
+    }
+
+    send_data "foo", options
+  end
+
+  def test_send_file_headers_with_disposition_as_a_symbol
+    options = {
+      type: Mime[:png],
+      disposition: :disposition,
+      filename: "filename"
+    }
+
+    send_data "foo", options
+  end
+
+  def test_send_file_headers_with_mime_lookup_with_symbol
+    options = { type: :png }
+
+    send_data "foo", options
+  end
+
+  def test_send_file_headers_with_bad_symbol
+    options = { type: :this_type_is_not_registered }
+    send_data "foo", options
+  end
+
+  def test_send_file_headers_with_nil_content_type
+    options = { type: nil }
+    send_data "foo", options
+  end
+
+  def test_send_file_headers_guess_type_from_extension
+    options = { filename: params[:filename] }
+    send_data "foo", options
+  end
+
+  def data
+    send_data(file_data, options)
+  end
+end
+
+class SendFileWithActionControllerLive < SendFileController
+  include ActionController::Live
+end
+
+class SendFileTest < ActionController::TestCase
+  include TestFileUtils
+
+  def setup
+    @controller = SendFileController.new
+  end
+
+  def test_file_nostream
+    @controller.options = { stream: false }
+    response = nil
+    assert_nothing_raised { response = process("file") }
+    assert_not_nil response
+    body = response.body
+    assert_kind_of String, body
+    assert_equal file_data, body
+  end
+
+  def test_file_stream
+    response = nil
+    assert_nothing_raised { response = process("file") }
+    assert_not_nil response
+    assert_respond_to response.stream, :each
+    assert_respond_to response.stream, :to_path
+
+    require "stringio"
+    output = StringIO.new
+    output.binmode
+    output.string.force_encoding(file_data.encoding)
+    response.body_parts.each { |part| output << part.to_s }
+    assert_equal file_data, output.string
+  end
+
+  def test_file_url_based_filename
+    @controller.options = { url_based_filename: true }
+    response = nil
+    assert_nothing_raised { response = process("file") }
+    assert_not_nil response
+    assert_equal "attachment", response.headers["Content-Disposition"]
+  end
+
+  def test_data
+    response = nil
+    assert_nothing_raised { response = process("data") }
+    assert_not_nil response
+
+    assert_kind_of String, response.body
+    assert_equal file_data, response.body
+  end
+
+  def test_headers_after_send_shouldnt_include_charset
+    response = process("data")
+    assert_equal "application/octet-stream", response.headers["Content-Type"]
+
+    response = process("file")
+    assert_equal "application/octet-stream", response.headers["Content-Type"]
+  end
+
+  # Test that send_file_headers! is setting the correct HTTP headers.
+  def test_send_file_headers_bang
+    # Do it a few times: the resulting headers should be identical
+    # no matter how many times you send with the same options.
+    # Test resolving Ticket #458.
+    5.times do
+      get :test_send_file_headers_bang
+
+      assert_equal "image/png", response.content_type
+      assert_equal 'disposition; filename="filename"', response.get_header("Content-Disposition")
+      assert_equal "binary", response.get_header("Content-Transfer-Encoding")
+      assert_equal "private", response.get_header("Cache-Control")
+    end
+  end
+
+  def test_send_file_headers_with_disposition_as_a_symbol
+    get :test_send_file_headers_with_disposition_as_a_symbol
+
+    assert_equal 'disposition; filename="filename"', response.get_header("Content-Disposition")
+  end
+
+  def test_send_file_headers_with_mime_lookup_with_symbol
+    get __method__
+    assert_equal "image/png", response.content_type
+  end
+
+  def test_send_file_headers_with_bad_symbol
+    error = assert_raise(ArgumentError) { get __method__ }
+    assert_equal "Unknown MIME type this_type_is_not_registered", error.message
+  end
+
+  def test_send_file_headers_with_nil_content_type
+    error = assert_raise(ArgumentError) { get __method__ }
+    assert_equal ":type option required", error.message
+  end
+
+  def test_send_file_headers_guess_type_from_extension
+    {
+      "image.png" => "image/png",
+      "image.jpeg" => "image/jpeg",
+      "image.jpg" => "image/jpeg",
+      "image.tif" => "image/tiff",
+      "image.gif" => "image/gif",
+      "movie.mp4" => "video/mp4",
+      "file.zip" => "application/zip",
+      "file.unk" => "application/octet-stream",
+      "zip" => "application/octet-stream"
+    }.each do |filename, expected_type|
+      get __method__, params: { filename: filename }
+      assert_equal expected_type, response.content_type
+    end
+  end
+
+  def test_send_file_with_default_content_disposition_header
+    process("data")
+    assert_equal "attachment", @controller.headers["Content-Disposition"]
+  end
+
+  def test_send_file_without_content_disposition_header
+    @controller.options = { disposition: nil }
+    process("data")
+    assert_nil @controller.headers["Content-Disposition"]
+  end
+
+  def test_send_file_from_before_action
+    response = nil
+    assert_nothing_raised { response = process("file_from_before_action") }
+    assert_not_nil response
+
+    assert_kind_of String, response.body
+    assert_equal file_data, response.body
+  end
+
+  %w(file data).each do |method|
+    define_method "test_send_#{method}_status" do
+      @controller.options = { stream: false, status: 500 }
+      assert_not_nil process(method)
+      assert_equal 500, @response.status
+    end
+
+    define_method "test_send_#{method}_content_type" do
+      @controller.options = { stream: false, content_type: "application/x-ruby" }
+      assert_nothing_raised { assert_not_nil process(method) }
+      assert_equal "application/x-ruby", @response.content_type
+    end
+
+    define_method "test_default_send_#{method}_status" do
+      @controller.options = { stream: false }
+      assert_nothing_raised { assert_not_nil process(method) }
+      assert_equal 200, @response.status
+    end
+  end
+
+  def test_send_file_with_action_controller_live
+    @controller = SendFileWithActionControllerLive.new
+    @controller.options = { content_type: "application/x-ruby" }
+
+    response = process("file")
+    assert_equal 200, response.status
+  end
+
+  def test_send_file_charset_with_type_options_key
+    @controller = SendFileWithActionControllerLive.new
+    @controller.options = { type: "text/calendar; charset=utf-8" }
+    response = process("file")
+    assert_equal "text/calendar; charset=utf-8", response.headers["Content-Type"]
+  end
+
+  def test_send_file_charset_with_type_options_key_without_charset
+    @controller = SendFileWithActionControllerLive.new
+    @controller.options = { type: "image/png" }
+    response = process("file")
+    assert_equal "image/png", response.headers["Content-Type"]
+  end
+
+  def test_send_file_charset_with_content_type_options_key
+    @controller = SendFileWithActionControllerLive.new
+    @controller.options = { content_type: "text/calendar" }
+    response = process("file")
+    assert_equal "text/calendar", response.headers["Content-Type"]
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module ShowExceptions
+  class ShowExceptionsController < ActionController::Base
+    use ActionDispatch::ShowExceptions, ActionDispatch::PublicExceptions.new("#{FIXTURE_LOAD_PATH}/public")
+    use ActionDispatch::DebugExceptions
+
+    before_action only: :another_boom do
+      request.env["action_dispatch.show_detailed_exceptions"] = true
+    end
+
+    def boom
+      raise "boom!"
+    end
+
+    def another_boom
+      raise "boom!"
+    end
+
+    def show_detailed_exceptions?
+      request.local?
+    end
+  end
+
+  class ShowExceptionsTest < ActionDispatch::IntegrationTest
+    test "show error page from a remote ip" do
+      @app = ShowExceptionsController.action(:boom)
+      self.remote_addr = "208.77.188.166"
+      get "/"
+      assert_equal "500 error fixture\n", body
+    end
+
+    test "show diagnostics from a local ip if show_detailed_exceptions? is set to request.local?" do
+      @app = ShowExceptionsController.action(:boom)
+      ["127.0.0.1", "127.0.0.127", "127.12.1.1", "::1", "0:0:0:0:0:0:0:1", "0:0:0:0:0:0:0:1%0"].each do |ip_address|
+        self.remote_addr = ip_address
+        get "/"
+        assert_match(/boom/, body)
+      end
+    end
+
+    test "show diagnostics from a remote ip when env is already set" do
+      @app = ShowExceptionsController.action(:another_boom)
+      self.remote_addr = "208.77.188.166"
+      get "/"
+      assert_match(/boom/, body)
+    end
+  end
+
+  class ShowExceptionsOverriddenController < ShowExceptionsController
+    private
+
+      def show_detailed_exceptions?
+        params["detailed"] == "1"
+      end
+  end
+
+  class ShowExceptionsOverriddenTest < ActionDispatch::IntegrationTest
+    test "show error page" do
+      @app = ShowExceptionsOverriddenController.action(:boom)
+      get "/", params: { "detailed" => "0" }
+      assert_equal "500 error fixture\n", body
+    end
+
+    test "show diagnostics message" do
+      @app = ShowExceptionsOverriddenController.action(:boom)
+      get "/", params: { "detailed" => "1" }
+      assert_match(/boom/, body)
+    end
+  end
+
+  class ShowExceptionsFormatsTest < ActionDispatch::IntegrationTest
+    def test_render_json_exception
+      @app = ShowExceptionsOverriddenController.action(:boom)
+      get "/", headers: { "HTTP_ACCEPT" => "application/json" }
+      assert_response :internal_server_error
+      assert_equal "application/json", response.content_type.to_s
+      assert_equal({ status: 500, error: "Internal Server Error" }.to_json, response.body)
+    end
+
+    def test_render_xml_exception
+      @app = ShowExceptionsOverriddenController.action(:boom)
+      get "/", headers: { "HTTP_ACCEPT" => "application/xml" }
+      assert_response :internal_server_error
+      assert_equal "application/xml", response.content_type.to_s
+      assert_equal({ status: 500, error: "Internal Server Error" }.to_xml, response.body)
+    end
+
+    def test_render_fallback_exception
+      @app = ShowExceptionsOverriddenController.action(:boom)
+      get "/", headers: { "HTTP_ACCEPT" => "text/csv" }
+      assert_response :internal_server_error
+      assert_equal "text/html", response.content_type.to_s
+    end
+  end
+
+  class ShowFailsafeExceptionsTest < ActionDispatch::IntegrationTest
+    def test_render_failsafe_exception
+      @app = ShowExceptionsOverriddenController.action(:boom)
+      @exceptions_app = @app.instance_variable_get(:@exceptions_app)
+      @app.instance_variable_set(:@exceptions_app, nil)
+      $stderr = StringIO.new
+
+      get "/", headers: { "HTTP_ACCEPT" => "text/json" }
+      assert_response :internal_server_error
+      assert_equal "text/plain", response.content_type.to_s
+    ensure
+      @app.instance_variable_set(:@exceptions_app, @exceptions_app)
+      $stderr = STDERR
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module ActionController
+  class StreamingResponseTest < ActionController::TestCase
+    class TestController < ActionController::Base
+      def self.controller_path
+        "test"
+      end
+
+      def basic_stream
+        %w{ hello world }.each do |word|
+          response.stream.write word
+          response.stream.write "\n"
+        end
+        response.stream.close
+      end
+    end
+
+    tests TestController
+
+    def test_write_to_stream
+      get :basic_stream
+      assert_equal "hello\nworld\n", @response.body
+    end
+  end
+end

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

@@ -0,0 +1,1157 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "controller/fake_controllers"
+require "active_support/json/decoding"
+require "rails/engine"
+
+class TestCaseTest < ActionController::TestCase
+  def self.fixture_path; end
+
+  class TestController < ActionController::Base
+    def no_op
+      render plain: "dummy"
+    end
+
+    def set_flash
+      flash["test"] = ">#{flash["test"]}<"
+      render plain: "ignore me"
+    end
+
+    def delete_flash
+      flash.delete("test")
+      render plain: "ignore me"
+    end
+
+    def set_flash_now
+      flash.now["test_now"] = ">#{flash["test_now"]}<"
+      render plain: "ignore me"
+    end
+
+    def set_session
+      session["string"] = "A wonder"
+      session[:symbol] = "it works"
+      render plain: "Success"
+    end
+
+    def reset_the_session
+      reset_session
+      render plain: "ignore me"
+    end
+
+    def render_raw_post
+      raise ActiveSupport::TestCase::Assertion, "#raw_post is blank" if request.raw_post.blank?
+      render plain: request.raw_post
+    end
+
+    def render_body
+      render plain: request.body.read
+    end
+
+    def test_params
+      render plain: ::JSON.dump(params.to_unsafe_h)
+    end
+
+    def test_query_parameters
+      render plain: ::JSON.dump(request.query_parameters)
+    end
+
+    def test_request_parameters
+      render plain: request.request_parameters.inspect
+    end
+
+    def test_uri
+      render plain: request.fullpath
+    end
+
+    def test_format
+      render plain: request.format
+    end
+
+    def test_query_string
+      render plain: request.query_string
+    end
+
+    def test_protocol
+      render plain: request.protocol
+    end
+
+    def test_headers
+      render plain: ::JSON.dump(request.headers.env)
+    end
+
+    def test_html_output
+      render plain: <<HTML
+<html>
+  <body>
+    <a href="/"><img src="/images/button.png" /></a>
+    <div id="foo">
+      <ul>
+        <li class="item">hello</li>
+        <li class="item">goodbye</li>
+      </ul>
+    </div>
+    <div id="bar">
+      <form action="/somewhere">
+        Name: <input type="text" name="person[name]" id="person_name" />
+      </form>
+    </div>
+  </body>
+</html>
+HTML
+    end
+
+    def test_xml_output
+      response.content_type = params[:response_as]
+      render plain: <<XML
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+  <area><p>area is an empty tag in HTML, so it won't contain this content</p></area>
+</root>
+XML
+    end
+
+    def test_only_one_param
+      render plain: (params[:left] && params[:right]) ? "EEP, Both here!" : "OK"
+    end
+
+    def test_remote_addr
+      render plain: (request.remote_addr || "not specified")
+    end
+
+    def test_file_upload
+      render plain: params[:file].size
+    end
+
+    def test_send_file
+      send_file(__FILE__)
+    end
+
+    def redirect_to_same_controller
+      redirect_to controller: "test", action: "test_uri", id: 5
+    end
+
+    def redirect_to_different_controller
+      redirect_to controller: "fail", id: 5
+    end
+
+    def create
+      head :created, location: "/resource"
+    end
+
+    def render_cookie
+      render plain: cookies["foo"]
+    end
+
+    def delete_cookie
+      cookies.delete("foo")
+      render plain: "ok"
+    end
+
+    def test_without_body
+      render html: '<div class="foo"></div>'.html_safe
+    end
+
+    def test_with_body
+      render html: '<body class="foo"></body>'.html_safe
+    end
+
+    def boom
+      raise "boom!"
+    end
+
+    private
+
+      def generate_url(opts)
+        url_for(opts.merge(action: "test_uri"))
+      end
+  end
+
+  def setup
+    super
+    @controller = TestController.new
+    @request.delete_header "PATH_INFO"
+    @routes = ActionDispatch::Routing::RouteSet.new.tap do |r|
+      r.draw do
+        ActiveSupport::Deprecation.silence do
+          get ":controller(/:action(/:id))"
+        end
+      end
+    end
+  end
+
+  class DefaultUrlOptionsCachingController < ActionController::Base
+    before_action { @dynamic_opt = "opt" }
+
+    def test_url_options_reset
+      render plain: url_for
+    end
+
+    def default_url_options
+      if defined?(@dynamic_opt)
+        super.merge dynamic_opt: @dynamic_opt
+      else
+        super
+      end
+    end
+  end
+
+  def test_assert_select_without_body
+    get :test_without_body
+
+    assert_select "body", 0
+    assert_select "div.foo"
+  end
+
+  def test_assert_select_with_body
+    get :test_with_body
+
+    assert_select "body.foo"
+  end
+
+  def test_url_options_reset
+    @controller = DefaultUrlOptionsCachingController.new
+    get :test_url_options_reset
+    assert_nil @request.params["dynamic_opt"]
+    assert_match(/dynamic_opt=opt/, @response.body)
+  end
+
+  def test_raw_post_handling
+    params = Hash[:page, { name: "page name" }, "some key", 123]
+    post :render_raw_post, params: params.dup
+
+    assert_equal params.to_query, @response.body
+  end
+
+  def test_params_round_trip
+    params = {"foo"=>{"contents"=>[{"name"=>"gorby", "id"=>"123"}, {"name"=>"puff", "d"=>"true"}]}}
+    post :test_params, params: params.dup
+
+    controller_info = { "controller" => "test_case_test/test", "action" => "test_params" }
+    assert_equal params.merge(controller_info), JSON.parse(@response.body)
+  end
+
+  def test_handle_to_params
+    klass = Class.new do
+      def to_param
+        "bar"
+      end
+    end
+
+    post :test_params, params: { foo: klass.new }
+
+    assert_equal JSON.parse(@response.body)["foo"], "bar"
+  end
+
+
+  def test_body_stream
+    params = Hash[:page, { name: "page name" }, "some key", 123]
+
+    post :render_body, params: params.dup
+
+    assert_equal params.to_query, @response.body
+  end
+
+  def test_document_body_and_params_with_post
+    post :test_params, params: { id: 1 }
+    assert_equal({ "id" => "1", "controller" => "test_case_test/test", "action" => "test_params" }, ::JSON.parse(@response.body))
+  end
+
+  def test_document_body_with_post
+    post :render_body, body: "document body"
+    assert_equal "document body", @response.body
+  end
+
+  def test_document_body_with_put
+    put :render_body, body: "document body"
+    assert_equal "document body", @response.body
+  end
+
+  def test_head
+    head :test_params
+    assert_equal 200, @response.status
+  end
+
+  def test_process_without_flash
+    process :set_flash
+    assert_equal "><", flash["test"]
+  end
+
+  def test_process_with_flash
+    process :set_flash,
+      method: "GET",
+      flash: { "test" => "value" }
+    assert_equal ">value<", flash["test"]
+  end
+
+  def test_process_with_flash_now
+    process :set_flash_now,
+      method: "GET",
+      flash: { "test_now" => "value_now" }
+    assert_equal ">value_now<", flash["test_now"]
+  end
+
+  def test_process_delete_flash
+    process :set_flash
+    process :delete_flash
+    assert_empty flash
+    assert_empty session
+  end
+
+  def test_process_with_session
+    process :set_session
+    assert_equal "A wonder", session["string"], "A value stored in the session should be available by string key"
+    assert_equal "A wonder", session[:string], "Test session hash should allow indifferent access"
+    assert_equal "it works", session["symbol"], "Test session hash should allow indifferent access"
+    assert_equal "it works", session[:symbol], "Test session hash should allow indifferent access"
+  end
+
+  def test_process_with_session_kwarg
+    process :no_op, method: "GET", session: { "string" => "value1", symbol: "value2" }
+    assert_equal "value1", session["string"]
+    assert_equal "value1", session[:string]
+    assert_equal "value2", session["symbol"]
+    assert_equal "value2", session[:symbol]
+  end
+
+  def test_process_merges_session_arg
+    session[:foo] = "bar"
+    get :no_op, session: { bar: "baz" }
+    assert_equal "bar", session[:foo]
+    assert_equal "baz", session[:bar]
+  end
+
+  def test_merged_session_arg_is_retained_across_requests
+    get :no_op, session: { foo: "bar" }
+    assert_equal "bar", session[:foo]
+    get :no_op
+    assert_equal "bar", session[:foo]
+  end
+
+  def test_process_overwrites_existing_session_arg
+    session[:foo] = "bar"
+    get :no_op, session: { foo: "baz" }
+    assert_equal "baz", session[:foo]
+  end
+
+  def test_session_is_cleared_from_controller_after_reset_session
+    process :set_session
+    process :reset_the_session
+    assert_equal Hash.new, @controller.session.to_hash
+  end
+
+  def test_session_is_cleared_from_request_after_reset_session
+    process :set_session
+    process :reset_the_session
+    assert_equal Hash.new, @request.session.to_hash
+  end
+
+  def test_response_and_request_have_nice_accessors
+    process :no_op
+    assert_equal @response, response
+    assert_equal @request, request
+  end
+
+  def test_process_with_request_uri_with_no_params
+    process :test_uri
+    assert_equal "/test_case_test/test/test_uri", @response.body
+  end
+
+  def test_process_with_symbol_method
+    process :test_uri, method: :get
+    assert_equal "/test_case_test/test/test_uri", @response.body
+  end
+
+  def test_process_with_request_uri_with_params
+    process :test_uri,
+      method: "GET",
+      params: { id: 7 }
+
+    assert_equal "/test_case_test/test/test_uri/7", @response.body
+  end
+
+  def test_process_with_request_uri_with_params_with_explicit_uri
+    @request.env["PATH_INFO"] = "/explicit/uri"
+    process :test_uri, method: "GET", params: { id: 7 }
+    assert_equal "/explicit/uri", @response.body
+  end
+
+  def test_process_with_query_string
+    process :test_query_string,
+      method: "GET",
+      params: { q: "test" }
+    assert_equal "q=test", @response.body
+  end
+
+  def test_process_with_query_string_with_explicit_uri
+    @request.env["PATH_INFO"] = "/explicit/uri"
+    @request.env["QUERY_STRING"] = "q=test?extra=question"
+    process :test_query_string
+    assert_equal "q=test?extra=question", @response.body
+  end
+
+  def test_multiple_calls
+    process :test_only_one_param, method: "GET", params: { left: true }
+    assert_equal "OK", @response.body
+    process :test_only_one_param, method: "GET", params: { right: true }
+    assert_equal "OK", @response.body
+  end
+
+  def test_should_impose_childless_html_tags_in_html
+    process :test_xml_output, params: { response_as: "text/html" }
+
+    # <area> auto-closes, so the <p> becomes a sibling
+    assert_select "root > area + p"
+  end
+
+  def test_should_not_impose_childless_html_tags_in_xml
+    process :test_xml_output, params: { response_as: "application/xml" }
+
+    # <area> is not special, so the <p> is its child
+    assert_select "root > area > p"
+  end
+
+  def test_assert_generates
+    assert_generates "controller/action/5", controller: "controller", action: "action", id: "5"
+    assert_generates "controller/action/7", { id: "7" }, { controller: "controller", action: "action" }
+    assert_generates "controller/action/5", { controller: "controller", action: "action", id: "5", name: "bob" }, {}, { name: "bob" }
+    assert_generates "controller/action/7", { id: "7", name: "bob" }, { controller: "controller", action: "action" }, { name: "bob" }
+    assert_generates "controller/action/7", { id: "7" }, { controller: "controller", action: "action", name: "bob" }, {}
+  end
+
+  def test_assert_routing
+    assert_routing "content", controller: "content", action: "index"
+  end
+
+  def test_assert_routing_with_method
+    with_routing do |set|
+      set.draw { resources(:content) }
+      assert_routing({ method: "post", path: "content" }, { controller: "content", action: "create" })
+    end
+  end
+
+  def test_assert_routing_in_module
+    with_routing do |set|
+      set.draw do
+        namespace :admin do
+          get "user" => "user#index"
+        end
+      end
+
+      assert_routing "admin/user", controller: "admin/user", action: "index"
+    end
+  end
+
+  def test_assert_routing_with_glob
+    with_routing do |set|
+      set.draw { get("*path" => "pages#show") }
+      assert_routing("/company/about", controller: "pages", action: "show", path: "company/about")
+    end
+  end
+
+  def test_params_passing
+    get :test_params, params: {
+      page: {
+        name: "Page name",
+        month: "4",
+        year: "2004",
+        day: "6"
+      }
+    }
+    parsed_params = ::JSON.parse(@response.body)
+    assert_equal(
+      {
+        "controller" => "test_case_test/test", "action" => "test_params",
+        "page" => { "name" => "Page name", "month" => "4", "year" => "2004", "day" => "6" }
+      },
+      parsed_params
+    )
+  end
+
+  def test_query_param_named_action
+    get :test_query_parameters, params: { action: "foobar" }
+    parsed_params = JSON.parse(@response.body)
+    assert_equal({ "action" => "foobar" }, parsed_params)
+  end
+
+  def test_request_param_named_action
+    post :test_request_parameters, params: { action: "foobar" }
+    parsed_params = eval(@response.body)
+    assert_equal({ "action" => "foobar" }, parsed_params)
+  end
+
+  def test_kwarg_params_passing_with_session_and_flash
+    get :test_params, params: {
+      page: {
+        name: "Page name",
+        month: "4",
+        year: "2004",
+        day: "6"
+      }
+    }, session: { "foo" => "bar" }, flash: { notice: "created" }
+
+    parsed_params = ::JSON.parse(@response.body)
+    assert_equal(
+      { "controller" => "test_case_test/test", "action" => "test_params",
+       "page" => { "name" => "Page name", "month" => "4", "year" => "2004", "day" => "6" } },
+      parsed_params
+    )
+
+    assert_equal "bar", session[:foo]
+    assert_equal "created", flash[:notice]
+  end
+
+  def test_params_passing_with_integer
+    get :test_params, params: {
+      page: { name: "Page name", month: 4, year: 2004, day: 6 }
+    }
+    parsed_params = ::JSON.parse(@response.body)
+    assert_equal(
+      { "controller" => "test_case_test/test", "action" => "test_params",
+       "page" => { "name" => "Page name", "month" => "4", "year" => "2004", "day" => "6" } },
+      parsed_params
+    )
+  end
+
+  def test_params_passing_with_integers_when_not_html_request
+    get :test_params, params: { format: "json", count: 999 }
+    parsed_params = ::JSON.parse(@response.body)
+    assert_equal(
+      { "controller" => "test_case_test/test", "action" => "test_params",
+       "format" => "json", "count" => "999" },
+      parsed_params
+    )
+  end
+
+  def test_params_passing_path_parameter_is_string_when_not_html_request
+    get :test_params, params: { format: "json", id: 1 }
+    parsed_params = ::JSON.parse(@response.body)
+    assert_equal(
+      { "controller" => "test_case_test/test", "action" => "test_params",
+       "format" => "json", "id" => "1" },
+      parsed_params
+    )
+  end
+
+  def test_params_passing_with_frozen_values
+    assert_nothing_raised do
+      get :test_params, params: {
+        frozen: "icy".freeze, frozens: ["icy".freeze].freeze, deepfreeze: { frozen: "icy".freeze }.freeze
+      }
+    end
+    parsed_params = ::JSON.parse(@response.body)
+    assert_equal(
+      { "controller" => "test_case_test/test", "action" => "test_params",
+       "frozen" => "icy", "frozens" => ["icy"], "deepfreeze" => { "frozen" => "icy" } },
+      parsed_params
+    )
+  end
+
+  def test_params_passing_doesnt_modify_in_place
+    page = { name: "Page name", month: 4, year: 2004, day: 6 }
+    get :test_params, params: { page: page }
+    assert_equal 2004, page[:year]
+  end
+
+  test "set additional HTTP headers" do
+    @request.headers["Referer"] = "http://nohost.com/home"
+    @request.headers["Content-Type"] = "application/rss+xml"
+    get :test_headers
+    parsed_env = ActiveSupport::JSON.decode(@response.body)
+    assert_equal "http://nohost.com/home", parsed_env["HTTP_REFERER"]
+    assert_equal "application/rss+xml", parsed_env["CONTENT_TYPE"]
+  end
+
+  test "set additional env variables" do
+    @request.headers["HTTP_REFERER"] = "http://example.com/about"
+    @request.headers["CONTENT_TYPE"] = "application/json"
+    get :test_headers
+    parsed_env = ActiveSupport::JSON.decode(@response.body)
+    assert_equal "http://example.com/about", parsed_env["HTTP_REFERER"]
+    assert_equal "application/json", parsed_env["CONTENT_TYPE"]
+  end
+
+  def test_using_as_json_sets_request_content_type_to_json
+    post :render_body, params: { bool_value: true, str_value: "string", num_value: 2 }, as: :json
+
+    assert_equal "application/json", @request.headers["CONTENT_TYPE"]
+    assert_equal true, @request.request_parameters[:bool_value]
+    assert_equal "string", @request.request_parameters[:str_value]
+    assert_equal 2, @request.request_parameters[:num_value]
+  end
+
+  def test_using_as_json_sets_format_json
+    post :render_body, params: { bool_value: true, str_value: "string", num_value: 2 }, as: :json
+    assert_equal "json", @request.format
+  end
+
+  def test_mutating_content_type_headers_for_plain_text_files_sets_the_header
+    @request.headers["Content-Type"] = "text/plain"
+    post :render_body, params: { name: "foo.txt" }
+
+    assert_equal "text/plain", @request.headers["Content-type"]
+    assert_equal "foo.txt", @request.request_parameters[:name]
+    assert_equal "render_body", @request.path_parameters[:action]
+  end
+
+  def test_mutating_content_type_headers_for_html_files_sets_the_header
+    @request.headers["Content-Type"] = "text/html"
+    post :render_body, params: { name: "foo.html" }
+
+    assert_equal "text/html", @request.headers["Content-type"]
+    assert_equal "foo.html", @request.request_parameters[:name]
+    assert_equal "render_body", @request.path_parameters[:action]
+  end
+
+  def test_mutating_content_type_headers_for_non_registered_mime_type_raises_an_error
+    assert_raises(RuntimeError) do
+      @request.headers["Content-Type"] = "type/fake"
+      post :render_body, params: { name: "foo.fake" }
+    end
+  end
+
+  def test_id_converted_to_string
+    get :test_params, params: {
+      id: 20, foo: Object.new
+    }
+    assert_kind_of String, @request.path_parameters[:id]
+  end
+
+  def test_array_path_parameter_handled_properly
+    with_routing do |set|
+      set.draw do
+        get "file/*path", to: "test_case_test/test#test_params"
+
+        ActiveSupport::Deprecation.silence do
+          get ":controller/:action"
+        end
+      end
+
+      get :test_params, params: { path: ["hello", "world"] }
+      assert_equal ["hello", "world"], @request.path_parameters[:path]
+      assert_equal "hello/world", @request.path_parameters[:path].to_param
+    end
+  end
+
+  def test_assert_realistic_path_parameters
+    get :test_params, params: { id: 20, foo: Object.new }
+
+    # All elements of path_parameters should use Symbol keys
+    @request.path_parameters.each_key do |key|
+      assert_kind_of Symbol, key
+    end
+  end
+
+  def test_with_routing_places_routes_back
+    assert @routes
+    routes_id = @routes.object_id
+
+    begin
+      with_routing { raise "fail" }
+      fail "Should not be here."
+    rescue RuntimeError
+    end
+
+    assert @routes
+    assert_equal routes_id, @routes.object_id
+  end
+
+  def test_remote_addr
+    get :test_remote_addr
+    assert_equal "0.0.0.0", @response.body
+
+    @request.remote_addr = "192.0.0.1"
+    get :test_remote_addr
+    assert_equal "192.0.0.1", @response.body
+  end
+
+  def test_header_properly_reset_after_remote_http_request
+    get :test_params, xhr: true
+    assert_nil @request.env["HTTP_X_REQUESTED_WITH"]
+    assert_nil @request.env["HTTP_ACCEPT"]
+  end
+
+  def test_xhr_with_params
+    get :test_params, params: { id: 1 }, xhr: true
+
+    assert_equal({ "id" => "1", "controller" => "test_case_test/test", "action" => "test_params" }, ::JSON.parse(@response.body))
+  end
+
+  def test_xhr_with_session
+    get :set_session, xhr: true
+
+    assert_equal "A wonder", session["string"], "A value stored in the session should be available by string key"
+    assert_equal "A wonder", session[:string], "Test session hash should allow indifferent access"
+    assert_equal "it works", session["symbol"], "Test session hash should allow indifferent access"
+    assert_equal "it works", session[:symbol], "Test session hash should allow indifferent access"
+  end
+
+  def test_params_reset_between_post_requests
+    post :no_op, params: { foo: "bar" }
+    assert_equal "bar", @request.params[:foo]
+
+    post :no_op
+    assert_predicate @request.params[:foo], :blank?
+  end
+
+  def test_filtered_parameters_reset_between_requests
+    get :no_op, params: { foo: "bar" }
+    assert_equal "bar", @request.filtered_parameters[:foo]
+
+    get :no_op, params: { foo: "baz" }
+    assert_equal "baz", @request.filtered_parameters[:foo]
+  end
+
+  def test_raw_post_reset_between_post_requests
+    post :no_op, params: { foo: "bar" }
+    assert_equal "foo=bar", @request.raw_post
+
+    post :no_op, params: { foo: "baz" }
+    assert_equal "foo=baz", @request.raw_post
+  end
+
+  def test_content_length_reset_after_post_request
+    post :no_op, params: { foo: "bar" }
+    assert_not_equal 0, @request.content_length
+
+    get :no_op
+    assert_equal 0, @request.content_length
+  end
+
+  def test_path_is_kept_after_the_request
+    get :test_params, params: { id: "foo" }
+    assert_equal "/test_case_test/test/test_params/foo", @request.path
+  end
+
+  def test_path_params_reset_between_request
+    get :test_params, params: { id: "foo" }
+    assert_equal "foo", @request.path_parameters[:id]
+
+    get :test_params
+    assert_nil @request.path_parameters[:id]
+  end
+
+  def test_request_protocol_is_reset_after_request
+    get :test_protocol
+    assert_equal "http://", @response.body
+
+    @request.env["HTTPS"] = "on"
+    get :test_protocol
+    assert_equal "https://", @response.body
+
+    @request.env.delete("HTTPS")
+    get :test_protocol
+    assert_equal "http://", @response.body
+  end
+
+  def test_request_format
+    get :test_format, params: { format: "html" }
+    assert_equal "text/html", @response.body
+
+    get :test_format, params: { format: "json" }
+    assert_equal "application/json", @response.body
+
+    get :test_format, params: { format: "xml" }
+    assert_equal "application/xml", @response.body
+
+    get :test_format
+    assert_equal "text/html", @response.body
+  end
+
+  def test_request_format_kwarg
+    get :test_format, format: "html"
+    assert_equal "text/html", @response.body
+
+    get :test_format, format: "json"
+    assert_equal "application/json", @response.body
+
+    get :test_format, format: "xml"
+    assert_equal "application/xml", @response.body
+
+    get :test_format
+    assert_equal "text/html", @response.body
+  end
+
+  def test_request_format_kwarg_overrides_params
+    get :test_format, format: "json", params: { format: "html" }
+    assert_equal "application/json", @response.body
+  end
+
+  def test_should_have_knowledge_of_client_side_cookie_state_even_if_they_are_not_set
+    cookies["foo"] = "bar"
+    get :no_op
+    assert_equal "bar", cookies["foo"]
+  end
+
+  def test_cookies_should_be_escaped_properly
+    cookies["foo"] = "+"
+    get :render_cookie
+    assert_equal "+", @response.body
+  end
+
+  def test_should_detect_if_cookie_is_deleted
+    cookies["foo"] = "bar"
+    get :delete_cookie
+    assert_nil cookies["foo"]
+  end
+
+  def test_multiple_mixed_method_process_should_scrub_rack_input
+    post :test_params, params: { id: 1, foo: "an foo" }
+    assert_equal({ "id" => "1", "foo" => "an foo", "controller" => "test_case_test/test", "action" => "test_params" }, ::JSON.parse(@response.body))
+
+    get :test_params, params: { bar: "an bar" }
+    assert_equal({ "bar" => "an bar", "controller" => "test_case_test/test", "action" => "test_params" }, ::JSON.parse(@response.body))
+  end
+
+  %w(controller response request).each do |variable|
+    %w(get post put delete head process).each do |method|
+      define_method("test_#{variable}_missing_for_#{method}_raises_error") do
+        remove_instance_variable "@#{variable}"
+        begin
+          send(method, :test_remote_addr)
+          assert false, "expected RuntimeError, got nothing"
+        rescue RuntimeError => error
+          assert_match(%r{@#{variable} is nil}, error.message)
+        rescue => error
+          assert false, "expected RuntimeError, got #{error.class}"
+        end
+      end
+    end
+  end
+
+  FILES_DIR = File.expand_path("../fixtures/multipart", __dir__)
+
+  READ_BINARY = "rb:binary"
+  READ_PLAIN = "r:binary"
+
+  def test_test_uploaded_file
+    filename = "ruby_on_rails.jpg"
+    path = "#{FILES_DIR}/#{filename}"
+    content_type = "image/png"
+    expected = File.read(path)
+    expected.force_encoding(Encoding::BINARY)
+
+    file = Rack::Test::UploadedFile.new(path, content_type)
+    assert_equal filename, file.original_filename
+    assert_equal content_type, file.content_type
+    assert_equal file.path, file.local_path
+    assert_equal expected, file.read
+
+    new_content_type = "new content_type"
+    file.content_type = new_content_type
+    assert_equal new_content_type, file.content_type
+  end
+
+  def test_fixture_path_is_accessed_from_self_instead_of_active_support_test_case
+    TestCaseTest.stub :fixture_path, FILES_DIR do
+      uploaded_file = fixture_file_upload("/ruby_on_rails.jpg", "image/png")
+      assert_equal File.open("#{FILES_DIR}/ruby_on_rails.jpg", READ_PLAIN).read, uploaded_file.read
+    end
+  end
+
+  def test_test_uploaded_file_with_binary
+    filename = "ruby_on_rails.jpg"
+    path = "#{FILES_DIR}/#{filename}"
+    content_type = "image/png"
+
+    binary_uploaded_file = Rack::Test::UploadedFile.new(path, content_type, :binary)
+    assert_equal File.open(path, READ_BINARY).read, binary_uploaded_file.read
+
+    plain_uploaded_file = Rack::Test::UploadedFile.new(path, content_type)
+    assert_equal File.open(path, READ_PLAIN).read, plain_uploaded_file.read
+  end
+
+  def test_fixture_file_upload_with_binary
+    filename = "ruby_on_rails.jpg"
+    path = "#{FILES_DIR}/#{filename}"
+    content_type = "image/jpg"
+
+    binary_file_upload = fixture_file_upload(path, content_type, :binary)
+    assert_equal File.open(path, READ_BINARY).read, binary_file_upload.read
+
+    plain_file_upload = fixture_file_upload(path, content_type)
+    assert_equal File.open(path, READ_PLAIN).read, plain_file_upload.read
+  end
+
+  def test_fixture_file_upload_should_be_able_access_to_tempfile
+    file = fixture_file_upload(FILES_DIR + "/ruby_on_rails.jpg", "image/jpg")
+    assert_respond_to file, :tempfile
+  end
+
+  def test_fixture_file_upload
+    post :test_file_upload,
+      params: {
+        file: fixture_file_upload(FILES_DIR + "/ruby_on_rails.jpg", "image/jpg")
+      }
+    assert_equal "45142", @response.body
+  end
+
+  def test_fixture_file_upload_relative_to_fixture_path
+    TestCaseTest.stub :fixture_path, FILES_DIR do
+      uploaded_file = fixture_file_upload("ruby_on_rails.jpg", "image/jpg")
+      assert_equal File.open("#{FILES_DIR}/ruby_on_rails.jpg", READ_PLAIN).read, uploaded_file.read
+    end
+  end
+
+  def test_fixture_file_upload_ignores_fixture_path_given_full_path
+    TestCaseTest.stub :fixture_path, __dir__ do
+      uploaded_file = fixture_file_upload("#{FILES_DIR}/ruby_on_rails.jpg", "image/jpg")
+      assert_equal File.open("#{FILES_DIR}/ruby_on_rails.jpg", READ_PLAIN).read, uploaded_file.read
+    end
+  end
+
+  def test_fixture_file_upload_ignores_nil_fixture_path
+    uploaded_file = fixture_file_upload("#{FILES_DIR}/ruby_on_rails.jpg", "image/jpg")
+    assert_equal File.open("#{FILES_DIR}/ruby_on_rails.jpg", READ_PLAIN).read, uploaded_file.read
+  end
+
+  def test_action_dispatch_uploaded_file_upload
+    filename = "ruby_on_rails.jpg"
+    path = "#{FILES_DIR}/#{filename}"
+    post :test_file_upload, params: {
+      file: Rack::Test::UploadedFile.new(path, "image/jpg", true)
+    }
+    assert_equal "45142", @response.body
+  end
+
+  def test_test_uploaded_file_exception_when_file_doesnt_exist
+    assert_raise(RuntimeError) { Rack::Test::UploadedFile.new("non_existent_file") }
+  end
+
+  def test_redirect_url_only_cares_about_location_header
+    get :create
+    assert_response :created
+
+    # Redirect url doesn't care that it wasn't a :redirect response.
+    assert_equal "/resource", @response.redirect_url
+    assert_equal @response.redirect_url, redirect_to_url
+
+    # Must be a :redirect response.
+    assert_raise(ActiveSupport::TestCase::Assertion) do
+      assert_redirected_to "/resource"
+    end
+  end
+
+  def test_exception_in_action_reaches_test
+    assert_raise(RuntimeError) do
+      process :boom, method: "GET"
+    end
+  end
+
+  def test_request_state_is_cleared_after_exception
+    assert_raise(RuntimeError) do
+      process :boom,
+        method: "GET",
+        params: { q: "test1" }
+    end
+
+    process :test_query_string,
+      method: "GET",
+      params: { q: "test2" }
+
+    assert_equal "q=test2", @response.body
+  end
+end
+
+class ResponseDefaultHeadersTest < ActionController::TestCase
+  class TestController < ActionController::Base
+    def remove_header
+      headers.delete params[:header]
+      head :ok, "C" => "3"
+    end
+
+    # Render a head response, but don't touch default headers
+    def leave_alone
+      head :ok
+    end
+  end
+
+  def before_setup
+    @original = ActionDispatch::Response.default_headers
+    @defaults = { "A" => "1", "B" => "2" }
+    ActionDispatch::Response.default_headers = @defaults
+    super
+  end
+
+  teardown do
+    ActionDispatch::Response.default_headers = @original
+  end
+
+  def setup
+    super
+    @controller = TestController.new
+    @request.env["PATH_INFO"] = nil
+    @routes = ActionDispatch::Routing::RouteSet.new.tap do |r|
+      r.draw do
+        ActiveSupport::Deprecation.silence do
+          get ":controller(/:action(/:id))"
+        end
+      end
+    end
+  end
+
+  test "response contains default headers" do
+    get :leave_alone
+
+    # Response headers start out with the defaults
+    assert_equal @defaults.merge("Content-Type" => "text/html"), response.headers
+  end
+
+  test "response deletes a default header" do
+    get :remove_header, params: { header: "A" }
+    assert_response :ok
+
+    # After a request, the response in the test case doesn't have the
+    # defaults merged on top again.
+    assert_not_includes response.headers, "A"
+    assert_includes response.headers, "B"
+    assert_includes response.headers, "C"
+  end
+end
+
+module EngineControllerTests
+  class Engine < ::Rails::Engine
+    isolate_namespace EngineControllerTests
+
+    routes.draw do
+      get "/" => "bar#index"
+    end
+  end
+
+  class BarController < ActionController::Base
+    def index
+      render plain: "bar"
+    end
+  end
+
+  class BarControllerTest < ActionController::TestCase
+    tests BarController
+
+    def test_engine_controller_route
+      get :index
+      assert_equal @response.body, "bar"
+    end
+  end
+
+  class BarControllerTestWithExplicitRouteSet < ActionController::TestCase
+    tests BarController
+
+    def setup
+      @routes = Engine.routes
+    end
+
+    def test_engine_controller_route
+      get :index
+      assert_equal @response.body, "bar"
+    end
+  end
+end
+
+class InferringClassNameTest < ActionController::TestCase
+  def test_determine_controller_class
+    assert_equal ContentController, determine_class("ContentControllerTest")
+  end
+
+  def test_determine_controller_class_with_nonsense_name
+    assert_nil determine_class("HelloGoodBye")
+  end
+
+  def test_determine_controller_class_with_sensible_name_where_no_controller_exists
+    assert_nil determine_class("NoControllerWithThisNameTest")
+  end
+
+  private
+    def determine_class(name)
+      ActionController::TestCase.determine_default_controller_class(name)
+    end
+end
+
+class CrazyNameTest < ActionController::TestCase
+  tests ContentController
+
+  def test_controller_class_can_be_set_manually_not_just_inferred
+    assert_equal ContentController, self.class.controller_class
+  end
+end
+
+class CrazySymbolNameTest < ActionController::TestCase
+  tests :content
+
+  def test_set_controller_class_using_symbol
+    assert_equal ContentController, self.class.controller_class
+  end
+end
+
+class CrazyStringNameTest < ActionController::TestCase
+  tests "content"
+
+  def test_set_controller_class_using_string
+    assert_equal ContentController, self.class.controller_class
+  end
+end
+
+class NamedRoutesControllerTest < ActionController::TestCase
+  tests ContentController
+
+  def test_should_be_able_to_use_named_routes_before_a_request_is_done
+    with_routing do |set|
+      set.draw { resources :contents }
+      assert_equal "http://test.host/contents/new", new_content_url
+      assert_equal "http://test.host/contents/1", content_url(id: 1)
+    end
+  end
+end
+
+class AnonymousControllerTest < ActionController::TestCase
+  def setup
+    @controller = Class.new(ActionController::Base) do
+      def index
+        render plain: params[:controller]
+      end
+    end.new
+
+    @routes = ActionDispatch::Routing::RouteSet.new.tap do |r|
+      r.draw do
+        ActiveSupport::Deprecation.silence do
+          get ":controller(/:action(/:id))"
+        end
+      end
+    end
+  end
+
+  def test_controller_name
+    get :index
+    assert_equal "anonymous", @response.body
+  end
+end
+
+class RoutingDefaultsTest < ActionController::TestCase
+  def setup
+    @controller = Class.new(ActionController::Base) do
+      def post
+        render plain: request.fullpath
+      end
+
+      def project
+        render plain: request.fullpath
+      end
+    end.new
+
+    @routes = ActionDispatch::Routing::RouteSet.new.tap do |r|
+      r.draw do
+        get "/posts/:id", to: "anonymous#post", bucket_type: "post"
+        get "/projects/:id", to: "anonymous#project", defaults: { bucket_type: "project" }
+      end
+    end
+  end
+
+  def test_route_option_can_be_passed_via_process
+    get :post, params: { id: 1, bucket_type: "post" }
+    assert_equal "/posts/1", @response.body
+  end
+
+  def test_route_default_is_not_required_for_building_request_uri
+    get :project, params: { id: 2 }
+    assert_equal "/projects/2", @response.body
+  end
+end