jets 1.9.7 → 1.9.8

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

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-class HttpTokenAuthenticationTest < ActionController::TestCase
-  class DummyController < ActionController::Base
-    before_action :authenticate, only: :index
-    before_action :authenticate_with_request, only: :display
-    before_action :authenticate_long_credentials, only: :show
-
-    def index
-      render plain: "Hello Secret"
-    end
-
-    def display
-      render plain: "Definitely Maybe"
-    end
-
-    def show
-      render plain: "Only for loooooong credentials"
-    end
-
-    private
-
-      def authenticate
-        authenticate_or_request_with_http_token do |token, _|
-          token == "lifo"
-        end
-      end
-
-      def authenticate_with_request
-        if authenticate_with_http_token { |token, options| token == '"quote" pretty' && options[:algorithm] == "test" }
-          @logged_in = true
-        else
-          request_http_token_authentication("SuperSecret", "Authentication Failed\n")
-        end
-      end
-
-      def authenticate_long_credentials
-        authenticate_or_request_with_http_token do |token, options|
-          token == "1234567890123456789012345678901234567890" && options[:algorithm] == "test"
-        end
-      end
-  end
-
-  AUTH_HEADERS = ["HTTP_AUTHORIZATION", "X-HTTP_AUTHORIZATION", "X_HTTP_AUTHORIZATION", "REDIRECT_X_HTTP_AUTHORIZATION"]
-
-  tests DummyController
-
-  AUTH_HEADERS.each do |header|
-    test "successful authentication with #{header.downcase}" do
-      @request.env[header] = encode_credentials("lifo")
-      get :index
-
-      assert_response :success
-      assert_equal "Hello Secret", @response.body, "Authentication failed for request header #{header}"
-    end
-    test "successful authentication with #{header.downcase} and long credentials" do
-      @request.env[header] = encode_credentials("1234567890123456789012345678901234567890", algorithm: "test")
-      get :show
-
-      assert_response :success
-      assert_equal "Only for loooooong credentials", @response.body, "Authentication failed for request header #{header} and long credentials"
-    end
-  end
-
-  AUTH_HEADERS.each do |header|
-    test "unsuccessful authentication with #{header.downcase}" do
-      @request.env[header] = encode_credentials("h4x0r")
-      get :index
-
-      assert_response :unauthorized
-      assert_equal "HTTP Token: Access denied.\n", @response.body, "Authentication didn't fail for request header #{header}"
-    end
-    test "unsuccessful authentication with #{header.downcase} and long credentials" do
-      @request.env[header] = encode_credentials("h4x0rh4x0rh4x0rh4x0rh4x0rh4x0rh4x0rh4x0r")
-      get :show
-
-      assert_response :unauthorized
-      assert_equal "HTTP Token: Access denied.\n", @response.body, "Authentication didn't fail for request header #{header} and long credentials"
-    end
-  end
-
-  test "authentication request with badly formatted header" do
-    @request.env["HTTP_AUTHORIZATION"] = 'Token token$"lifo"'
-    get :index
-
-    assert_response :unauthorized
-    assert_equal "HTTP Token: Access denied.\n", @response.body, "Authentication header was not properly parsed"
-  end
-
-  test "successful authentication request with Bearer instead of Token" do
-    @request.env["HTTP_AUTHORIZATION"] = "Bearer lifo"
-    get :index
-
-    assert_response :success
-  end
-
-  test "authentication request with tab in header" do
-    @request.env["HTTP_AUTHORIZATION"] = "Token\ttoken=\"lifo\""
-    get :index
-
-    assert_response :success
-    assert_equal "Hello Secret", @response.body
-  end
-
-  test "authentication request without credential" do
-    get :display
-
-    assert_response :unauthorized
-    assert_equal "Authentication Failed\n", @response.body
-    assert_equal 'Token realm="SuperSecret"', @response.headers["WWW-Authenticate"]
-  end
-
-  test "authentication request with invalid credential" do
-    @request.env["HTTP_AUTHORIZATION"] = encode_credentials('"quote" pretty')
-    get :display
-
-    assert_response :unauthorized
-    assert_equal "Authentication Failed\n", @response.body
-    assert_equal 'Token realm="SuperSecret"', @response.headers["WWW-Authenticate"]
-  end
-
-  test "token_and_options returns correct token" do
-    token = "rcHu+HzSFw89Ypyhn/896A=="
-    actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token)).first
-    expected = token
-    assert_equal(expected, actual)
-  end
-
-  test "token_and_options returns correct token with value after the equal sign" do
-    token = "rcHu+=HzSFw89Ypyhn/896A==f34"
-    actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token)).first
-    expected = token
-    assert_equal(expected, actual)
-  end
-
-  test "token_and_options returns correct token with slashes" do
-    token = 'rcHu+\\\\"/896A'
-    actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token)).first
-    expected = token
-    assert_equal(expected, actual)
-  end
-
-  test "token_and_options returns correct token with quotes" do
-    token = '\"quote\" pretty'
-    actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token)).first
-    expected = token
-    assert_equal(expected, actual)
-  end
-
-  test "token_and_options returns empty string with empty token" do
-    token = "".dup
-    actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token)).first
-    expected = token
-    assert_equal(expected, actual)
-  end
-
-  test "token_and_options returns correct token with nounce option" do
-    token = "rcHu+HzSFw89Ypyhn/896A="
-    nonce_hash = { nonce: "123abc" }
-    actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token, nonce_hash))
-    expected_token = token
-    expected_nonce = { "nonce" => nonce_hash[:nonce] }
-    assert_equal(expected_token, actual.first)
-    assert_equal(expected_nonce, actual.last)
-  end
-
-  test "token_and_options returns nil with no value after the equal sign" do
-    actual = ActionController::HttpAuthentication::Token.token_and_options(malformed_request).first
-    assert_nil actual
-  end
-
-  test "raw_params returns a tuple of two key value pair strings" do
-    auth = sample_request("rcHu+HzSFw89Ypyhn/896A=").authorization.to_s
-    actual = ActionController::HttpAuthentication::Token.raw_params(auth)
-    expected = ["token=\"rcHu+HzSFw89Ypyhn/896A=\"", "nonce=\"def\""]
-    assert_equal(expected, actual)
-  end
-
-  test "token_and_options returns right token when token key is not specified in header" do
-    token = "rcHu+HzSFw89Ypyhn/896A="
-
-    actual = ActionController::HttpAuthentication::Token.token_and_options(
-      sample_request_without_token_key(token)
-    ).first
-
-    expected = token
-    assert_equal(expected, actual)
-  end
-
-  private
-
-    def sample_request(token, options = { nonce: "def" })
-      authorization = options.inject([%{Token token="#{token}"}]) do |arr, (k, v)|
-        arr << "#{k}=\"#{v}\""
-      end.join(", ")
-      mock_authorization_request(authorization)
-    end
-
-    def malformed_request
-      mock_authorization_request(%{Token token=})
-    end
-
-    def sample_request_without_token_key(token)
-      mock_authorization_request(%{Token #{token}})
-    end
-
-    def mock_authorization_request(authorization)
-      OpenStruct.new(authorization: authorization)
-    end
-
-    def encode_credentials(token, options = {})
-      ActionController::HttpAuthentication::Token.encode_credentials(token, options)
-    end
-end

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

@@ -1,1136 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-require "controller/fake_controllers"
-require "rails/engine"
-
-class SessionTest < ActiveSupport::TestCase
-  StubApp = lambda { |env|
-    [200, { "Content-Type" => "text/html", "Content-Length" => "13" }, ["Hello, World!"]]
-  }
-
-  def setup
-    @session = ActionDispatch::Integration::Session.new(StubApp)
-  end
-
-  def test_https_bang_works_and_sets_truth_by_default
-    assert_not_predicate @session, :https?
-    @session.https!
-    assert_predicate @session, :https?
-    @session.https! false
-    assert_not_predicate @session, :https?
-  end
-
-  def test_host!
-    assert_not_equal "glu.ttono.us", @session.host
-    @session.host! "rubyonrails.com"
-    assert_equal "rubyonrails.com", @session.host
-  end
-
-  def test_follow_redirect_raises_when_no_redirect
-    @session.stub :redirect?, false do
-      assert_raise(RuntimeError) { @session.follow_redirect! }
-    end
-  end
-
-  def test_get
-    path = "/index"; params = "blah"; headers = { location: "blah" }
-
-    assert_called_with @session, :process, [:get, path, params: params, headers: headers] do
-      @session.get(path, params: params, headers: headers)
-    end
-  end
-
-  def test_get_with_env_and_headers
-    path = "/index"; params = "blah"; headers = { location: "blah" }; env = { "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest" }
-    assert_called_with @session, :process, [:get, path, params: params, headers: headers, env: env] do
-      @session.get(path, params: params, headers: headers, env: env)
-    end
-  end
-
-  def test_post
-    path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:post, path, params: params, headers: headers] do
-      @session.post(path, params: params, headers: headers)
-    end
-  end
-
-  def test_patch
-    path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:patch, path, params: params, headers: headers] do
-      @session.patch(path, params: params, headers: headers)
-    end
-  end
-
-  def test_put
-    path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:put, path, params: params, headers: headers] do
-      @session.put(path, params: params, headers: headers)
-    end
-  end
-
-  def test_delete
-    path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:delete, path, params: params, headers: headers] do
-      @session.delete(path, params: params, headers: headers)
-    end
-  end
-
-  def test_head
-    path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:head, path, params: params, headers: headers] do
-      @session.head(path, params: params, headers: headers)
-    end
-  end
-
-  def test_xml_http_request_get
-    path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:get, path, params: params, headers: headers, xhr: true] do
-      @session.get(path, params: params, headers: headers, xhr: true)
-    end
-  end
-
-  def test_xml_http_request_post
-    path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:post, path, params: params, headers: headers, xhr: true] do
-      @session.post(path, params: params, headers: headers, xhr: true)
-    end
-  end
-
-  def test_xml_http_request_patch
-    path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:patch, path, params: params, headers: headers, xhr: true] do
-      @session.patch(path, params: params, headers: headers, xhr: true)
-    end
-  end
-
-  def test_xml_http_request_put
-    path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:put, path, params: params, headers: headers, xhr: true] do
-      @session.put(path, params: params, headers: headers, xhr: true)
-    end
-  end
-
-  def test_xml_http_request_delete
-    path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:delete, path, params: params, headers: headers, xhr: true] do
-      @session.delete(path, params: params, headers: headers, xhr: true)
-    end
-  end
-
-  def test_xml_http_request_head
-    path = "/index"; params = "blah"; headers = { location: "blah" }
-    assert_called_with @session, :process, [:head, path, params: params, headers: headers, xhr: true] do
-      @session.head(path, params: params, headers: headers, xhr: true)
-    end
-  end
-end
-
-class IntegrationTestTest < ActiveSupport::TestCase
-  def setup
-    @test = ::ActionDispatch::IntegrationTest.new(:app)
-  end
-
-  def test_opens_new_session
-    session1 = @test.open_session { |sess| }
-    session2 = @test.open_session # implicit session
-
-    assert !session1.equal?(session2)
-  end
-
-  # RSpec mixes Matchers (which has a #method_missing) into
-  # IntegrationTest's superclass.  Make sure IntegrationTest does not
-  # try to delegate these methods to the session object.
-  def test_does_not_prevent_method_missing_passing_up_to_ancestors
-    mixin = Module.new do
-      def method_missing(name, *args)
-        name.to_s == "foo" ? "pass" : super
-      end
-    end
-    @test.class.superclass.include(mixin)
-    begin
-      assert_equal "pass", @test.foo
-    ensure
-      # leave other tests as unaffected as possible
-      mixin.__send__(:remove_method, :method_missing)
-    end
-  end
-end
-
-# Tests that integration tests don't call Controller test methods for processing.
-# Integration tests have their own setup and teardown.
-class IntegrationTestUsesCorrectClass < ActionDispatch::IntegrationTest
-  def test_integration_methods_called
-    reset!
-
-    %w( get post head patch put delete ).each do |verb|
-      assert_nothing_raised { __send__(verb, "/") }
-    end
-  end
-end
-
-class IntegrationProcessTest < ActionDispatch::IntegrationTest
-  class IntegrationController < ActionController::Base
-    def get
-      respond_to do |format|
-        format.html { render plain: "OK", status: 200 }
-        format.js { render plain: "JS OK", status: 200 }
-        format.json { render json: "JSON OK", status: 200 }
-        format.xml { render xml: "<root></root>", status: 200 }
-        format.rss { render xml: "<root></root>", status: 200 }
-        format.atom { render xml: "<root></root>", status: 200 }
-      end
-    end
-
-    def get_with_params
-      render plain: "foo: #{params[:foo]}", status: 200
-    end
-
-    def post
-      render plain: "Created", status: 201
-    end
-
-    def method
-      render plain: "method: #{request.method.downcase}"
-    end
-
-    def cookie_monster
-      cookies["cookie_1"] = nil
-      cookies["cookie_3"] = "chocolate"
-      render plain: "Gone", status: 410
-    end
-
-    def set_cookie
-      cookies["foo"] = "bar"
-      head :ok
-    end
-
-    def get_cookie
-      render plain: cookies["foo"]
-    end
-
-    def redirect
-      redirect_to action_url("get")
-    end
-
-    def remove_header
-      response.headers.delete params[:header]
-      head :ok, "c" => "3"
-    end
-  end
-
-  def test_get
-    with_test_route_set do
-      get "/get"
-      assert_equal 200, status
-      assert_equal "OK", status_message
-      assert_response 200
-      assert_response :success
-      assert_response :ok
-      assert_equal({}, cookies.to_hash)
-      assert_equal "OK", body
-      assert_equal "OK", response.body
-      assert_kind_of Nokogiri::HTML::Document, html_document
-      assert_equal 1, request_count
-    end
-  end
-
-  def test_get_xml_rss_atom
-    %w[ application/xml application/rss+xml application/atom+xml ].each do |mime_string|
-      with_test_route_set do
-        get "/get", headers: { "HTTP_ACCEPT" => mime_string }
-        assert_equal 200, status
-        assert_equal "OK", status_message
-        assert_response 200
-        assert_response :success
-        assert_response :ok
-        assert_equal({}, cookies.to_hash)
-        assert_equal "<root></root>", body
-        assert_equal "<root></root>", response.body
-        assert_instance_of Nokogiri::XML::Document, html_document
-        assert_equal 1, request_count
-      end
-    end
-  end
-
-  def test_post
-    with_test_route_set do
-      post "/post"
-      assert_equal 201, status
-      assert_equal "Created", status_message
-      assert_response 201
-      assert_response :success
-      assert_response :created
-      assert_equal({}, cookies.to_hash)
-      assert_equal "Created", body
-      assert_equal "Created", response.body
-      assert_kind_of Nokogiri::HTML::Document, html_document
-      assert_equal 1, request_count
-    end
-  end
-
-  test "response cookies are added to the cookie jar for the next request" do
-    with_test_route_set do
-      cookies["cookie_1"] = "sugar"
-      cookies["cookie_2"] = "oatmeal"
-      get "/cookie_monster"
-      assert_equal "cookie_1=; path=/\ncookie_3=chocolate; path=/", headers["Set-Cookie"]
-      assert_equal({ "cookie_1" => "", "cookie_2" => "oatmeal", "cookie_3" => "chocolate" }, cookies.to_hash)
-    end
-  end
-
-  test "cookie persist to next request" do
-    with_test_route_set do
-      get "/set_cookie"
-      assert_response :success
-
-      assert_equal "foo=bar; path=/", headers["Set-Cookie"]
-      assert_equal({ "foo" => "bar" }, cookies.to_hash)
-
-      get "/get_cookie"
-      assert_response :success
-      assert_equal "bar", body
-
-      assert_nil headers["Set-Cookie"]
-      assert_equal({ "foo" => "bar" }, cookies.to_hash)
-    end
-  end
-
-  test "cookie persist to next request on another domain" do
-    with_test_route_set do
-      host! "37s.backpack.test"
-
-      get "/set_cookie"
-      assert_response :success
-
-      assert_equal "foo=bar; path=/", headers["Set-Cookie"]
-      assert_equal({ "foo" => "bar" }, cookies.to_hash)
-
-      get "/get_cookie"
-      assert_response :success
-      assert_equal "bar", body
-
-      assert_nil headers["Set-Cookie"]
-      assert_equal({ "foo" => "bar" }, cookies.to_hash)
-    end
-  end
-
-  def test_redirect
-    with_test_route_set do
-      get "/redirect"
-      assert_equal 302, status
-      assert_equal "Found", status_message
-      assert_response 302
-      assert_response :redirect
-      assert_response :found
-      assert_equal "<html><body>You are being <a href=\"http://www.example.com/get\">redirected</a>.</body></html>", response.body
-      assert_kind_of Nokogiri::HTML::Document, html_document
-      assert_equal 1, request_count
-
-      follow_redirect!
-      assert_response :success
-      assert_equal "/get", path
-
-      get "/moved"
-      assert_response :redirect
-      assert_redirected_to "/method"
-    end
-  end
-
-  def test_redirect_reset_html_document
-    with_test_route_set do
-      get "/redirect"
-      previous_html_document = html_document
-
-      follow_redirect!
-
-      assert_response :ok
-      refute_same previous_html_document, html_document
-    end
-  end
-
-  def test_xml_http_request_get
-    with_test_route_set do
-      get "/get", xhr: true
-      assert_equal 200, status
-      assert_equal "OK", status_message
-      assert_response 200
-      assert_response :success
-      assert_response :ok
-      assert_equal "JS OK", response.body
-    end
-  end
-
-  def test_request_with_bad_format
-    with_test_route_set do
-      get "/get.php", xhr: true
-      assert_equal 406, status
-      assert_response 406
-      assert_response :not_acceptable
-    end
-  end
-
-  test "creation of multiple integration sessions" do
-    integration_session # initialize first session
-    a = open_session
-    b = open_session
-
-    refute_same(a.integration_session, b.integration_session)
-  end
-
-  def test_get_with_query_string
-    with_test_route_set do
-      get "/get_with_params?foo=bar"
-      assert_equal "/get_with_params?foo=bar", request.env["REQUEST_URI"]
-      assert_equal "/get_with_params?foo=bar", request.fullpath
-      assert_equal "foo=bar", request.env["QUERY_STRING"]
-      assert_equal "foo=bar", request.query_string
-      assert_equal "bar", request.parameters["foo"]
-
-      assert_equal 200, status
-      assert_equal "foo: bar", response.body
-    end
-  end
-
-  def test_get_with_parameters
-    with_test_route_set do
-      get "/get_with_params", params: { foo: "bar" }
-      assert_equal "/get_with_params", request.env["PATH_INFO"]
-      assert_equal "/get_with_params", request.path_info
-      assert_equal "foo=bar", request.env["QUERY_STRING"]
-      assert_equal "foo=bar", request.query_string
-      assert_equal "bar", request.parameters["foo"]
-
-      assert_equal 200, status
-      assert_equal "foo: bar", response.body
-    end
-  end
-
-  def test_post_then_get_with_parameters_do_not_leak_across_requests
-    with_test_route_set do
-      post "/post", params: { leaks: "does-leak?" }
-
-      get "/get_with_params", params: { foo: "bar" }
-
-      assert_empty request.env["rack.input"].string
-      assert_equal "foo=bar", request.env["QUERY_STRING"]
-      assert_equal "foo=bar", request.query_string
-      assert_equal "bar", request.parameters["foo"]
-      assert_predicate request.parameters["leaks"], :nil?
-    end
-  end
-
-  def test_head
-    with_test_route_set do
-      head "/get"
-      assert_equal 200, status
-      assert_equal "", body
-
-      head "/post"
-      assert_equal 201, status
-      assert_equal "", body
-
-      get "/get/method"
-      assert_equal 200, status
-      assert_equal "method: get", body
-
-      head "/get/method"
-      assert_equal 200, status
-      assert_equal "", body
-    end
-  end
-
-  def test_generate_url_with_controller
-    assert_equal "http://www.example.com/foo", url_for(controller: "foo")
-  end
-
-  def test_port_via_host!
-    with_test_route_set do
-      host! "www.example.com:8080"
-      get "/get"
-      assert_equal 8080, request.port
-    end
-  end
-
-  def test_port_via_process
-    with_test_route_set do
-      get "http://www.example.com:8080/get"
-      assert_equal 8080, request.port
-    end
-  end
-
-  def test_https_and_port_via_host_and_https!
-    with_test_route_set do
-      host! "www.example.com"
-      https! true
-
-      get "/get"
-      assert_equal 443, request.port
-      assert_equal true, request.ssl?
-
-      host! "www.example.com:443"
-      https! true
-
-      get "/get"
-      assert_equal 443, request.port
-      assert_equal true, request.ssl?
-
-      host! "www.example.com:8443"
-      https! true
-
-      get "/get"
-      assert_equal 8443, request.port
-      assert_equal true, request.ssl?
-    end
-  end
-
-  def test_https_and_port_via_process
-    with_test_route_set do
-      get "https://www.example.com/get"
-      assert_equal 443, request.port
-      assert_equal true, request.ssl?
-
-      get "https://www.example.com:8443/get"
-      assert_equal 8443, request.port
-      assert_equal true, request.ssl?
-    end
-  end
-
-  def test_respect_removal_of_default_headers_by_a_controller_action
-    with_test_route_set do
-      with_default_headers "a" => "1", "b" => "2" do
-        get "/remove_header", params: { header: "a" }
-      end
-    end
-
-    assert_not_includes @response.headers, "a", "Response should not include default header removed by the controller action"
-    assert_includes @response.headers, "b"
-    assert_includes @response.headers, "c"
-  end
-
-  def test_accept_not_overridden_when_xhr_true
-    with_test_route_set do
-      get "/get", headers: { "Accept" => "application/json" }, xhr: true
-      assert_equal "application/json", request.accept
-      assert_equal "application/json", response.content_type
-
-      get "/get", headers: { "HTTP_ACCEPT" => "application/json" }, xhr: true
-      assert_equal "application/json", request.accept
-      assert_equal "application/json", response.content_type
-    end
-  end
-
-  private
-    def with_default_headers(headers)
-      original = ActionDispatch::Response.default_headers
-      ActionDispatch::Response.default_headers = headers
-      yield
-    ensure
-      ActionDispatch::Response.default_headers = original
-    end
-
-    def with_test_route_set
-      with_routing do |set|
-        controller = ::IntegrationProcessTest::IntegrationController.clone
-        controller.class_eval do
-          include set.url_helpers
-        end
-
-        set.draw do
-          get "moved" => redirect("/method")
-
-          ActiveSupport::Deprecation.silence do
-            match ":action", to: controller, via: [:get, :post], as: :action
-            get "get/:action", to: controller, as: :get_action
-          end
-        end
-
-        singleton_class.include(set.url_helpers)
-
-        yield
-      end
-    end
-end
-
-class MetalIntegrationTest < ActionDispatch::IntegrationTest
-  include SharedTestRoutes.url_helpers
-
-  class Poller
-    def self.call(env)
-      if env["PATH_INFO"] =~ /^\/success/
-        [200, { "Content-Type" => "text/plain", "Content-Length" => "12" }, ["Hello World!"]]
-      else
-        [404, { "Content-Type" => "text/plain", "Content-Length" => "0" }, []]
-      end
-    end
-  end
-
-  def setup
-    @app = Poller
-  end
-
-  def test_successful_get
-    get "/success"
-    assert_response 200
-    assert_response :success
-    assert_response :ok
-    assert_equal "Hello World!", response.body
-  end
-
-  def test_failed_get
-    get "/failure"
-    assert_response 404
-    assert_response :not_found
-    assert_equal "", response.body
-  end
-
-  def test_generate_url_without_controller
-    assert_equal "http://www.example.com/foo", url_for(controller: "foo")
-  end
-
-  def test_pass_headers
-    get "/success", headers: { "Referer" => "http://www.example.com/foo", "Host" => "http://nohost.com" }
-
-    assert_equal "http://nohost.com", @request.env["HTTP_HOST"]
-    assert_equal "http://www.example.com/foo", @request.env["HTTP_REFERER"]
-  end
-
-  def test_pass_headers_and_env
-    get "/success", headers: { "X-Test-Header" => "value" }, env: { "HTTP_REFERER" => "http://test.com/", "HTTP_HOST" => "http://test.com" }
-
-    assert_equal "http://test.com", @request.env["HTTP_HOST"]
-    assert_equal "http://test.com/", @request.env["HTTP_REFERER"]
-    assert_equal "value", @request.env["HTTP_X_TEST_HEADER"]
-  end
-
-  def test_pass_env
-    get "/success", env: { "HTTP_REFERER" => "http://test.com/", "HTTP_HOST" => "http://test.com" }
-
-    assert_equal "http://test.com", @request.env["HTTP_HOST"]
-    assert_equal "http://test.com/", @request.env["HTTP_REFERER"]
-  end
-
-  def test_ignores_common_ports_in_host
-    get "http://test.com"
-    assert_equal "test.com", @request.env["HTTP_HOST"]
-
-    get "https://test.com"
-    assert_equal "test.com", @request.env["HTTP_HOST"]
-  end
-
-  def test_keeps_uncommon_ports_in_host
-    get "http://test.com:123"
-    assert_equal "test.com:123", @request.env["HTTP_HOST"]
-
-    get "http://test.com:443"
-    assert_equal "test.com:443", @request.env["HTTP_HOST"]
-
-    get "https://test.com:80"
-    assert_equal "test.com:80", @request.env["HTTP_HOST"]
-  end
-end
-
-class ApplicationIntegrationTest < ActionDispatch::IntegrationTest
-  class TestController < ActionController::Base
-    def index
-      render plain: "index"
-    end
-  end
-
-  def self.call(env)
-    routes.call(env)
-  end
-
-  def self.routes
-    @routes ||= ActionDispatch::Routing::RouteSet.new
-  end
-
-  class MountedApp < Rails::Engine
-    def self.routes
-      @routes ||= ActionDispatch::Routing::RouteSet.new
-    end
-
-    routes.draw do
-      get "baz", to: "application_integration_test/test#index", as: :baz
-    end
-
-    def self.call(*)
-    end
-  end
-
-  routes.draw do
-    get "",    to: "application_integration_test/test#index", as: :empty_string
-
-    get "foo", to: "application_integration_test/test#index", as: :foo
-    get "bar", to: "application_integration_test/test#index", as: :bar
-
-    mount MountedApp => "/mounted", :as => "mounted"
-    get "fooz" => proc { |env| [ 200, { "X-Cascade" => "pass" }, [ "omg" ] ] }, :anchor => false
-    get "fooz", to: "application_integration_test/test#index"
-  end
-
-  def app
-    self.class
-  end
-
-  test "includes route helpers" do
-    assert_equal "/", empty_string_path
-    assert_equal "/foo", foo_path
-    assert_equal "/bar", bar_path
-  end
-
-  test "includes mounted helpers" do
-    assert_equal "/mounted/baz", mounted.baz_path
-  end
-
-  test "path after cascade pass" do
-    get "/fooz"
-    assert_equal "index", response.body
-    assert_equal "/fooz", path
-  end
-
-  test "route helpers after controller access" do
-    get "/"
-    assert_equal "/", empty_string_path
-
-    get "/foo"
-    assert_equal "/foo", foo_path
-
-    get "/bar"
-    assert_equal "/bar", bar_path
-  end
-
-  test "missing route helper before controller access" do
-    assert_raise(NameError) { missing_path }
-  end
-
-  test "missing route helper after controller access" do
-    get "/foo"
-    assert_raise(NameError) { missing_path }
-  end
-
-  test "process do not modify the env passed as argument" do
-    env = { :SERVER_NAME => "server", "action_dispatch.custom" => "custom" }
-    old_env = env.dup
-    get "/foo", env: env
-    assert_equal old_env, env
-  end
-end
-
-class EnvironmentFilterIntegrationTest < ActionDispatch::IntegrationTest
-  class TestController < ActionController::Base
-    def post
-      render plain: "Created", status: 201
-    end
-  end
-
-  def self.call(env)
-    env["action_dispatch.parameter_filter"] = [:password]
-    routes.call(env)
-  end
-
-  def self.routes
-    @routes ||= ActionDispatch::Routing::RouteSet.new
-  end
-
-  routes.draw do
-    match "/post", to: "environment_filter_integration_test/test#post", via: :post
-  end
-
-  def app
-    self.class
-  end
-
-  test "filters rack request form vars" do
-    post "/post", params: { username: "cjolly", password: "secret" }
-
-    assert_equal "cjolly", request.filtered_parameters["username"]
-    assert_equal "[FILTERED]", request.filtered_parameters["password"]
-    assert_equal "[FILTERED]", request.filtered_env["rack.request.form_vars"]
-  end
-end
-
-class UrlOptionsIntegrationTest < ActionDispatch::IntegrationTest
-  class FooController < ActionController::Base
-    def index
-      render plain: "foo#index"
-    end
-
-    def show
-      render plain: "foo#show"
-    end
-
-    def edit
-      render plain: "foo#show"
-    end
-  end
-
-  class BarController < ActionController::Base
-    def default_url_options
-      { host: "bar.com" }
-    end
-
-    def index
-      render plain: "foo#index"
-    end
-  end
-
-  def self.routes
-    @routes ||= ActionDispatch::Routing::RouteSet.new
-  end
-
-  def self.call(env)
-    routes.call(env)
-  end
-
-  def app
-    self.class
-  end
-
-  routes.draw do
-    default_url_options host: "foo.com"
-
-    scope module: "url_options_integration_test" do
-      get "/foo" => "foo#index", :as => :foos
-      get "/foo/:id" => "foo#show", :as => :foo
-      get "/foo/:id/edit" => "foo#edit", :as => :edit_foo
-      get "/bar" => "bar#index", :as => :bars
-    end
-  end
-
-  test "session uses default url options from routes" do
-    assert_equal "http://foo.com/foo", foos_url
-  end
-
-  test "current host overrides default url options from routes" do
-    get "/foo"
-    assert_response :success
-    assert_equal "http://www.example.com/foo", foos_url
-  end
-
-  test "controller can override default url options from request" do
-    get "/bar"
-    assert_response :success
-    assert_equal "http://bar.com/foo", foos_url
-  end
-
-  def test_can_override_default_url_options
-    original_host = default_url_options.dup
-
-    default_url_options[:host] = "foobar.com"
-    assert_equal "http://foobar.com/foo", foos_url
-
-    get "/bar"
-    assert_response :success
-    assert_equal "http://foobar.com/foo", foos_url
-  ensure
-    ActionDispatch::Integration::Session.default_url_options = self.default_url_options = original_host
-  end
-
-  test "current request path parameters are recalled" do
-    get "/foo/1"
-    assert_response :success
-    assert_equal "/foo/1/edit", url_for(action: "edit", only_path: true)
-  end
-end
-
-class HeadWithStatusActionIntegrationTest < ActionDispatch::IntegrationTest
-  class FooController < ActionController::Base
-    def status
-      head :ok
-    end
-  end
-
-  def self.routes
-    @routes ||= ActionDispatch::Routing::RouteSet.new
-  end
-
-  def self.call(env)
-    routes.call(env)
-  end
-
-  def app
-    self.class
-  end
-
-  routes.draw do
-    get "/foo/status" => "head_with_status_action_integration_test/foo#status"
-  end
-
-  test "get /foo/status with head result does not cause stack overflow error" do
-    assert_nothing_raised do
-      get "/foo/status"
-    end
-    assert_response :ok
-  end
-end
-
-class IntegrationWithRoutingTest < ActionDispatch::IntegrationTest
-  class FooController < ActionController::Base
-    def index
-      render plain: "ok"
-    end
-  end
-
-  def test_with_routing_resets_session
-    klass_namespace = self.class.name.underscore
-
-    with_routing do |routes|
-      routes.draw do
-        namespace klass_namespace do
-          resources :foo, path: "/with"
-        end
-      end
-
-      get "/integration_with_routing_test/with"
-      assert_response 200
-      assert_equal "ok", response.body
-    end
-
-    with_routing do |routes|
-      routes.draw do
-        namespace klass_namespace do
-          resources :foo, path: "/routing"
-        end
-      end
-
-      get "/integration_with_routing_test/routing"
-      assert_response 200
-      assert_equal "ok", response.body
-    end
-  end
-end
-
-# to work in contexts like rspec before(:all)
-class IntegrationRequestsWithoutSetup < ActionDispatch::IntegrationTest
-  self._setup_callbacks = []
-  self._teardown_callbacks = []
-
-  class FooController < ActionController::Base
-    def ok
-      cookies[:key] = "ok"
-      render plain: "ok"
-    end
-  end
-
-  def test_request
-    with_routing do |routes|
-      routes.draw do
-        ActiveSupport::Deprecation.silence do
-          get ":action" => FooController
-        end
-      end
-
-      get "/ok"
-
-      assert_response 200
-      assert_equal "ok", response.body
-      assert_equal "ok", cookies["key"]
-    end
-  end
-end
-
-# to ensure that session requirements in setup are persisted in the tests
-class IntegrationRequestsWithSessionSetup < ActionDispatch::IntegrationTest
-  setup do
-    cookies["user_name"] = "david"
-  end
-
-  def test_cookies_set_in_setup_are_persisted_through_the_session
-    get "/foo"
-    assert_equal({ "user_name" => "david" }, cookies.to_hash)
-  end
-end
-
-class IntegrationRequestEncodersTest < ActionDispatch::IntegrationTest
-  class FooController < ActionController::Base
-    def foos
-      render plain: "ok"
-    end
-
-    def foos_json
-      render json: params.permit(:foo)
-    end
-
-    def foos_wibble
-      render plain: "ok"
-    end
-  end
-
-  def test_standard_json_encoding_works
-    with_routing do |routes|
-      routes.draw do
-        ActiveSupport::Deprecation.silence do
-          post ":action" => FooController
-        end
-      end
-
-      post "/foos_json.json", params: { foo: "fighters" }.to_json,
-        headers: { "Content-Type" => "application/json" }
-
-      assert_response :success
-      assert_equal({ "foo" => "fighters" }, response.parsed_body)
-    end
-  end
-
-  def test_encoding_as_json
-    post_to_foos as: :json do
-      assert_response :success
-      assert_equal "application/json", request.content_type
-      assert_equal "application/json", request.accepts.first.to_s
-      assert_equal :json, request.format.ref
-      assert_equal({ "foo" => "fighters" }, request.request_parameters)
-      assert_equal({ "foo" => "fighters" }, response.parsed_body)
-    end
-  end
-
-  def test_doesnt_mangle_request_path
-    with_routing do |routes|
-      routes.draw do
-        ActiveSupport::Deprecation.silence do
-          post ":action" => FooController
-        end
-      end
-
-      post "/foos"
-      assert_equal "/foos", request.path
-
-      post "/foos_json", as: :json
-      assert_equal "/foos_json", request.path
-    end
-  end
-
-  def test_encoding_as_without_mime_registration
-    assert_raise ArgumentError do
-      ActionDispatch::IntegrationTest.register_encoder :wibble
-    end
-  end
-
-  def test_registering_custom_encoder
-    Mime::Type.register "text/wibble", :wibble
-
-    ActionDispatch::IntegrationTest.register_encoder(:wibble,
-      param_encoder: -> params { params })
-
-    post_to_foos as: :wibble do
-      assert_response :success
-      assert_equal "/foos_wibble", request.path
-      assert_equal "text/wibble", request.content_type
-      assert_equal "text/wibble", request.accepts.first.to_s
-      assert_equal :wibble, request.format.ref
-      assert_equal Hash.new, request.request_parameters # Unregistered MIME Type can't be parsed.
-      assert_equal "ok", response.parsed_body
-    end
-  ensure
-    Mime::Type.unregister :wibble
-  end
-
-  def test_parsed_body_without_as_option
-    with_routing do |routes|
-      routes.draw do
-        ActiveSupport::Deprecation.silence do
-          get ":action" => FooController
-        end
-      end
-
-      get "/foos_json.json", params: { foo: "heyo" }
-
-      assert_equal({ "foo" => "heyo" }, response.parsed_body)
-    end
-  end
-
-  def test_get_parameters_with_as_option
-    with_routing do |routes|
-      routes.draw do
-        ActiveSupport::Deprecation.silence do
-          get ":action" => FooController
-        end
-      end
-
-      get "/foos_json?foo=heyo", as: :json
-
-      assert_equal({ "foo" => "heyo" }, response.parsed_body)
-    end
-  end
-
-  def test_get_request_with_json_uses_method_override_and_sends_a_post_request
-    with_routing do |routes|
-      routes.draw do
-        ActiveSupport::Deprecation.silence do
-          get ":action" => FooController
-        end
-      end
-
-      get "/foos_json", params: { foo: "heyo" }, as: :json
-
-      assert_equal "POST", request.method
-      assert_equal "GET", request.headers["X-Http-Method-Override"]
-      assert_equal({ "foo" => "heyo" }, response.parsed_body)
-    end
-  end
-
-  def test_get_request_with_json_excludes_null_query_string
-    with_routing do |routes|
-      routes.draw do
-        ActiveSupport::Deprecation.silence do
-          get ":action" => FooController
-        end
-      end
-
-      get "/foos_json", as: :json
-
-      assert_equal "http://www.example.com/foos_json", request.url
-    end
-  end
-
-  private
-    def post_to_foos(as:)
-      with_routing do |routes|
-        routes.draw do
-          ActiveSupport::Deprecation.silence do
-            post ":action" => FooController
-          end
-        end
-
-        post "/foos_#{as}", params: { foo: "fighters" }, as: as
-
-        yield
-      end
-    end
-end
-
-class IntegrationFileUploadTest < ActionDispatch::IntegrationTest
-  class IntegrationController < ActionController::Base
-    def test_file_upload
-      render plain: params[:file].size
-    end
-  end
-
-  def self.routes
-    @routes ||= ActionDispatch::Routing::RouteSet.new
-  end
-
-  def self.call(env)
-    routes.call(env)
-  end
-
-  def app
-    self.class
-  end
-
-  def self.fixture_path
-    File.expand_path("../fixtures/multipart", __dir__)
-  end
-
-  routes.draw do
-    post "test_file_upload", to: "integration_file_upload_test/integration#test_file_upload"
-  end
-
-  def test_fixture_file_upload
-    post "/test_file_upload",
-      params: {
-        file: fixture_file_upload("/ruby_on_rails.jpg", "image/jpg")
-      }
-    assert_equal "45142", @response.body
-  end
-end