Merge branch 'master' into clear_all_environments_log_by_default

62 files changed, 510 insertions, 393 deletions

diff --git a/actionpack/test/abstract/collector_test.rb b/actionpack/test/abstract/collector_test.rb
index 7fe19e6b10..1cd3526483 100644
--- a/actionpack/test/abstract/collector_test.rb
+++ b/actionpack/test/abstract/collector_test.rb
@@ -55,7 +55,7 @@ module AbstractController
         collector.js(:bar) { :baz }
         assert_equal [Mime[:html], [], nil], collector.responses[0]
         assert_equal [Mime[:text], [:foo], nil], collector.responses[1]
-        assert_equal [Mime[:js], [:bar]], collector.responses[2][0,2]
+        assert_equal [Mime[:js], [:bar]], collector.responses[2][0, 2]
         assert_equal :baz, collector.responses[2][2].call
       end
     end
diff --git a/actionpack/test/abstract_unit.rb b/actionpack/test/abstract_unit.rb
index 6d28753947..11a9092527 100644
--- a/actionpack/test/abstract_unit.rb
+++ b/actionpack/test/abstract_unit.rb
@@ -351,7 +351,7 @@ class ResourcesController < ActionController::Base
 end
 
 class CommentsController < ResourcesController; end
-class AccountsController <  ResourcesController; end
+class AccountsController < ResourcesController; end
 class ImagesController < ResourcesController; end
 
 # Skips the current run on Rubinius using Minitest::Assertions#skip
diff --git a/actionpack/test/controller/caching_test.rb b/actionpack/test/controller/caching_test.rb
index 18490c7d73..fa8d9dc09a 100644
--- a/actionpack/test/controller/caching_test.rb
+++ b/actionpack/test/controller/caching_test.rb
@@ -58,7 +58,7 @@ class FragmentCachingTest < ActionController::TestCase
   def test_fragment_cache_key
     assert_equal "views/what a key", @controller.fragment_cache_key("what a key")
     assert_equal "views/test.host/fragment_caching_test/some_action",
-                  @controller.fragment_cache_key(controller: "fragment_caching_test",action: "some_action")
+                  @controller.fragment_cache_key(controller: "fragment_caching_test", action: "some_action")
   end
 
   def test_read_fragment_with_caching_enabled
diff --git a/actionpack/test/controller/filters_test.rb b/actionpack/test/controller/filters_test.rb
index a34878cee8..f9701585a9 100644
--- a/actionpack/test/controller/filters_test.rb
+++ b/actionpack/test/controller/filters_test.rb
@@ -55,7 +55,7 @@ class FilterTest < ActionController::TestCase
       end
     end
 
-    protected
+    private
       (1..3).each do |i|
         define_method "try_#{i}" do
           instance_variable_set :@try, i
@@ -296,7 +296,7 @@ class FilterTest < ActionController::TestCase
       render inline: "ran action"
     end
 
-    protected
+    private
       def find_user
         @ran_filter ||= []
         @ran_filter << "find_user"
@@ -428,7 +428,7 @@ class FilterTest < ActionController::TestCase
       render plain: "bar"
     end
 
-    protected
+    private
       def first
         @first = true
       end
@@ -506,20 +506,20 @@ class FilterTest < ActionController::TestCase
     private
 
       def filter_one
-        @filters  ||= []
-        @filters  << "filter_one"
+        @filters ||= []
+        @filters << "filter_one"
       end
 
       def action_two
-        @filters  << "action_two"
+        @filters << "action_two"
       end
 
       def non_yielding_action
-        @filters  << "it didn't yield"
+        @filters << "it didn't yield"
       end
 
       def action_three
-        @filters  << "action_three"
+        @filters << "action_three"
       end
   end
 
@@ -911,7 +911,7 @@ class ControllerWithFilterInstance < PostsController
 end
 
 class ControllerWithProcFilter < PostsController
-  around_action(only: :no_raise) do |c,b|
+  around_action(only: :no_raise) do |c, b|
     c.instance_variable_set(:"@before", true)
     b.call
     c.instance_variable_set(:"@after", true)
@@ -961,34 +961,34 @@ class YieldingAroundFiltersTest < ActionController::TestCase
 
   def test_base
     controller = PostsController
-    assert_nothing_raised { test_process(controller,"no_raise") }
-    assert_nothing_raised { test_process(controller,"raises_before") }
-    assert_nothing_raised { test_process(controller,"raises_after") }
-    assert_nothing_raised { test_process(controller,"no_action") }
+    assert_nothing_raised { test_process(controller, "no_raise") }
+    assert_nothing_raised { test_process(controller, "raises_before") }
+    assert_nothing_raised { test_process(controller, "raises_after") }
+    assert_nothing_raised { test_process(controller, "no_action") }
   end
 
   def test_with_symbol
     controller = ControllerWithSymbolAsFilter
-    assert_nothing_raised { test_process(controller,"no_raise") }
-    assert_raise(Before) { test_process(controller,"raises_before") }
-    assert_raise(After) { test_process(controller,"raises_after") }
-    assert_nothing_raised { test_process(controller,"no_raise") }
+    assert_nothing_raised { test_process(controller, "no_raise") }
+    assert_raise(Before) { test_process(controller, "raises_before") }
+    assert_raise(After) { test_process(controller, "raises_after") }
+    assert_nothing_raised { test_process(controller, "no_raise") }
   end
 
   def test_with_class
     controller = ControllerWithFilterClass
-    assert_nothing_raised { test_process(controller,"no_raise") }
-    assert_raise(After) { test_process(controller,"raises_after") }
+    assert_nothing_raised { test_process(controller, "no_raise") }
+    assert_raise(After) { test_process(controller, "raises_after") }
   end
 
   def test_with_instance
     controller = ControllerWithFilterInstance
-    assert_nothing_raised { test_process(controller,"no_raise") }
-    assert_raise(After) { test_process(controller,"raises_after") }
+    assert_nothing_raised { test_process(controller, "no_raise") }
+    assert_raise(After) { test_process(controller, "raises_after") }
   end
 
   def test_with_proc
-    test_process(ControllerWithProcFilter,"no_raise")
+    test_process(ControllerWithProcFilter, "no_raise")
     assert @controller.instance_variable_get(:@before)
     assert @controller.instance_variable_get(:@after)
   end
@@ -997,25 +997,25 @@ class YieldingAroundFiltersTest < ActionController::TestCase
     controller = ControllerWithNestedFilters
     assert_nothing_raised do
       begin
-        test_process(controller,"raises_both")
+        test_process(controller, "raises_both")
       rescue Before, After
       end
     end
     assert_raise Before do
       begin
-        test_process(controller,"raises_both")
+        test_process(controller, "raises_both")
       rescue After
       end
     end
   end
 
   def test_action_order_with_all_action_types
-    test_process(ControllerWithAllTypesOfFilters,"no_raise")
+    test_process(ControllerWithAllTypesOfFilters, "no_raise")
     assert_equal "before around (before yield) around_again (before yield) around_again (after yield) after around (after yield)", @controller.instance_variable_get(:@ran_filter).join(" ")
   end
 
   def test_action_order_with_skip_action_method
-    test_process(ControllerWithTwoLessFilters,"no_raise")
+    test_process(ControllerWithTwoLessFilters, "no_raise")
     assert_equal "before around (before yield) around (after yield)", @controller.instance_variable_get(:@ran_filter).join(" ")
   end
 
@@ -1040,7 +1040,7 @@ class YieldingAroundFiltersTest < ActionController::TestCase
     assert_equal 3, controller.instance_variable_get(:@try)
   end
 
-  protected
+  private
     def test_process(controller, action = "show")
       @controller = controller.is_a?(Class) ? controller.new : controller
       process(action)
diff --git a/actionpack/test/controller/flash_hash_test.rb b/actionpack/test/controller/flash_hash_test.rb
index 32f0db71f5..45b598a594 100644
--- a/actionpack/test/controller/flash_hash_test.rb
+++ b/actionpack/test/controller/flash_hash_test.rb
@@ -63,10 +63,10 @@ module ActionDispatch
       assert_equal({ "flashes" => { "foo" => "bar" }, "discard" => [] }, @hash.to_session_value)
 
       @hash.discard("foo")
-      assert_equal(nil, @hash.to_session_value)
+      assert_nil(@hash.to_session_value)
 
       @hash.sweep
-      assert_equal(nil, @hash.to_session_value)
+      assert_nil(@hash.to_session_value)
     end
 
     def test_from_session_value
@@ -75,7 +75,7 @@ module ActionDispatch
       session = Marshal.load(Base64.decode64(rails_3_2_cookie))
       hash = Flash::FlashHash.from_session_value(session["flash"])
       assert_equal({ "greeting" => "Hello" }, hash.to_hash)
-      assert_equal(nil, hash.to_session_value)
+      assert_nil(hash.to_session_value)
     end
 
     def test_from_session_value_on_json_serializer
@@ -84,7 +84,7 @@ module ActionDispatch
       hash = Flash::FlashHash.from_session_value(session["flash"])
 
       assert_equal({ "greeting" => "Hello" }, hash.to_hash)
-      assert_equal(nil, hash.to_session_value)
+      assert_nil(hash.to_session_value)
       assert_equal "Hello", hash[:greeting]
       assert_equal "Hello", hash["greeting"]
     end
@@ -102,8 +102,8 @@ module ActionDispatch
       @hash["foo"] = "bar"
 
       things = []
-      @hash.each do |k,v|
-        things << [k,v]
+      @hash.each do |k, v|
+        things << [k, v]
       end
 
       assert_equal([%w{ hello world }, %w{ foo bar }].sort, things.sort)
diff --git a/actionpack/test/controller/http_digest_authentication_test.rb b/actionpack/test/controller/http_digest_authentication_test.rb
index 343b7b643d..0b59e123d7 100644
--- a/actionpack/test/controller/http_digest_authentication_test.rb
+++ b/actionpack/test/controller/http_digest_authentication_test.rb
@@ -7,7 +7,7 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
     before_action :authenticate_with_request, only: :display
 
     USERS = { "lifo" => "world", "pretty" => "please",
-              "dhh" => ::Digest::MD5::hexdigest(["dhh","SuperSecret","secret"].join(":")) }
+              "dhh" => ::Digest::MD5::hexdigest(["dhh", "SuperSecret", "secret"].join(":")) }
 
     def index
       render plain: "Hello Secret"
@@ -180,7 +180,7 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
 
   test "authentication request with password stored as ha1 digest hash" do
     @request.env["HTTP_AUTHORIZATION"] = encode_credentials(username: "dhh",
-                                           password: ::Digest::MD5::hexdigest(["dhh","SuperSecret","secret"].join(":")),
+                                           password: ::Digest::MD5::hexdigest(["dhh", "SuperSecret", "secret"].join(":")),
                                            password_is_ha1: true)
     get :display
 
diff --git a/actionpack/test/controller/http_token_authentication_test.rb b/actionpack/test/controller/http_token_authentication_test.rb
index 3842136682..09d2793c9a 100644
--- a/actionpack/test/controller/http_token_authentication_test.rb
+++ b/actionpack/test/controller/http_token_authentication_test.rb
@@ -166,8 +166,7 @@ class HttpTokenAuthenticationTest < ActionController::TestCase
 
   test "token_and_options returns nil with no value after the equal sign" do
     actual = ActionController::HttpAuthentication::Token.token_and_options(malformed_request).first
-    expected = nil
-    assert_equal(expected, actual)
+    assert_nil actual
   end
 
   test "raw_params returns a tuple of two key value pair strings" do
diff --git a/actionpack/test/controller/integration_test.rb b/actionpack/test/controller/integration_test.rb
index 652c0f0dd2..4fae4071b1 100644
--- a/actionpack/test/controller/integration_test.rb
+++ b/actionpack/test/controller/integration_test.rb
@@ -145,7 +145,7 @@ class IntegrationTestTest < ActiveSupport::TestCase
         name.to_s == "foo" ? "pass" : super
       end
     end
-    @test.class.superclass.__send__(:include, mixin)
+    @test.class.superclass.include(mixin)
     begin
       assert_equal "pass", @test.foo
     ensure
@@ -153,14 +153,6 @@ class IntegrationTestTest < ActiveSupport::TestCase
       mixin.__send__(:remove_method, :method_missing)
     end
   end
-
-  def test_assigns_is_undefined_and_not_point_to_the_gem
-    e = assert_raises(NoMethodError) do
-      @test.assigns(:foo)
-    end
-
-    assert_match(/undefined method/, e.message)
-  end
 end
 
 # Tests that integration tests don't call Controller test methods for processing.
@@ -281,7 +273,7 @@ class IntegrationProcessTest < ActionDispatch::IntegrationTest
       self.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)
+      assert_equal({ "cookie_1" => "", "cookie_2" => "oatmeal", "cookie_3" => "chocolate" }, cookies.to_hash)
     end
   end
 
@@ -291,14 +283,14 @@ class IntegrationProcessTest < ActionDispatch::IntegrationTest
       assert_response :success
 
       assert_equal "foo=bar; path=/", headers["Set-Cookie"]
-      assert_equal({ "foo"=>"bar" }, cookies.to_hash)
+      assert_equal({ "foo" => "bar" }, cookies.to_hash)
 
       get "/get_cookie"
       assert_response :success
       assert_equal "bar", body
 
-      assert_equal nil, headers["Set-Cookie"]
-      assert_equal({ "foo"=>"bar" }, cookies.to_hash)
+      assert_nil headers["Set-Cookie"]
+      assert_equal({ "foo" => "bar" }, cookies.to_hash)
     end
   end
 
@@ -310,14 +302,14 @@ class IntegrationProcessTest < ActionDispatch::IntegrationTest
       assert_response :success
 
       assert_equal "foo=bar; path=/", headers["Set-Cookie"]
-      assert_equal({ "foo"=>"bar" }, cookies.to_hash)
+      assert_equal({ "foo" => "bar" }, cookies.to_hash)
 
       get "/get_cookie"
       assert_response :success
       assert_equal "bar", body
 
-      assert_equal nil, headers["Set-Cookie"]
-      assert_equal({ "foo"=>"bar" }, cookies.to_hash)
+      assert_nil headers["Set-Cookie"]
+      assert_equal({ "foo" => "bar" }, cookies.to_hash)
     end
   end
 
@@ -364,6 +356,14 @@ class IntegrationProcessTest < ActionDispatch::IntegrationTest
     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"
@@ -924,12 +924,16 @@ class IntegrationRequestsWithSessionSetup < ActionDispatch::IntegrationTest
 
   def test_cookies_set_in_setup_are_persisted_through_the_session
     get "/foo"
-    assert_equal({ "user_name"=>"david" }, cookies.to_hash)
+    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
@@ -958,13 +962,30 @@ class IntegrationRequestEncodersTest < ActionDispatch::IntegrationTest
   def test_encoding_as_json
     post_to_foos as: :json do
       assert_response :success
-      assert_match "foos_json.json", request.path
       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
@@ -979,8 +1000,10 @@ class IntegrationRequestEncodersTest < ActionDispatch::IntegrationTest
 
     post_to_foos as: :wibble do
       assert_response :success
-      assert_match "foos_wibble.wibble", request.path
+      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
@@ -1078,8 +1101,8 @@ class IntegrationFileUploadTest < ActionDispatch::IntegrationTest
   def test_fixture_file_upload
     post "/test_file_upload",
       params: {
-        file: fixture_file_upload("/mona_lisa.jpg", "image/jpg")
+        file: fixture_file_upload("/ruby_on_rails.jpg", "image/jpg")
       }
-    assert_equal "159528", @response.body
+    assert_equal "45142", @response.body
   end
 end
diff --git a/actionpack/test/controller/mime/accept_format_test.rb b/actionpack/test/controller/mime/accept_format_test.rb
index a2834c9f39..a22fa39051 100644
--- a/actionpack/test/controller/mime/accept_format_test.rb
+++ b/actionpack/test/controller/mime/accept_format_test.rb
@@ -40,7 +40,7 @@ class PostController < AbstractPostController
     respond_to(:html, :iphone, :js)
   end
 
-protected
+private
 
   def with_iphone
     request.format = "iphone" if request.env["HTTP_ACCEPT"] == "text/iphone"
diff --git a/actionpack/test/controller/mime/respond_to_test.rb b/actionpack/test/controller/mime/respond_to_test.rb
index c5f8165d04..818dc119eb 100644
--- a/actionpack/test/controller/mime/respond_to_test.rb
+++ b/actionpack/test/controller/mime/respond_to_test.rb
@@ -273,7 +273,7 @@ class RespondToController < ActionController::Base
     end
   end
 
-  protected
+  private
     def set_layout
       case action_name
       when "all_types_with_layout", "iphone_with_html_response_type"
diff --git a/actionpack/test/controller/new_base/bare_metal_test.rb b/actionpack/test/controller/new_base/bare_metal_test.rb
index 9956f0b107..054757fab3 100644
--- a/actionpack/test/controller/new_base/bare_metal_test.rb
+++ b/actionpack/test/controller/new_base/bare_metal_test.rb
@@ -52,7 +52,7 @@ module BareMetalTest
       controller.set_request!(ActionDispatch::Request.empty)
       controller.set_response!(BareController.make_response!(controller.request))
       controller.index
-      assert_equal nil, controller.response_body
+      assert_nil controller.response_body
     end
   end
 
diff --git a/actionpack/test/controller/new_base/base_test.rb b/actionpack/test/controller/new_base/base_test.rb
index 3765d406fc..b891df4c0f 100644
--- a/actionpack/test/controller/new_base/base_test.rb
+++ b/actionpack/test/controller/new_base/base_test.rb
@@ -25,7 +25,7 @@ module Dispatching
       render body: "actions: #{action_methods.to_a.sort.join(', ')}"
     end
 
-    protected
+    private
       def authenticate
       end
   end
diff --git a/actionpack/test/controller/new_base/render_context_test.rb b/actionpack/test/controller/new_base/render_context_test.rb
index b64468a94e..25b73ac78c 100644
--- a/actionpack/test/controller/new_base/render_context_test.rb
+++ b/actionpack/test/controller/new_base/render_context_test.rb
@@ -26,16 +26,14 @@ module RenderContext
       render action: "hello_world", layout: "basic"
     end
 
-    protected
-
-      # 3) Set view_context to self
-      def view_context
-        self
-      end
+    protected def __controller_method__
+      "controller context!"
+    end
 
-      def __controller_method__
-        "controller context!"
-      end
+    # 3) Set view_context to self
+    private def view_context
+      self
+    end
   end
 
   class RenderContextTest < Rack::TestCase
diff --git a/actionpack/test/controller/new_base/render_streaming_test.rb b/actionpack/test/controller/new_base/render_streaming_test.rb
index 5cd8f82323..1177b8b03e 100644
--- a/actionpack/test/controller/new_base/render_streaming_test.rb
+++ b/actionpack/test/controller/new_base/render_streaming_test.rb
@@ -101,12 +101,12 @@ module RenderStreaming
       assert_body "Hello world, I'm here!"
       assert_status 200
       assert_equal "22", headers["Content-Length"]
-      assert_equal nil, headers["Transfer-Encoding"]
+      assert_nil headers["Transfer-Encoding"]
     end
 
-    def assert_streaming!(cache="no-cache")
+    def assert_streaming!(cache = "no-cache")
       assert_status 200
-      assert_equal nil, headers["Content-Length"]
+      assert_nil headers["Content-Length"]
       assert_equal "chunked", headers["Transfer-Encoding"]
       assert_equal cache, headers["Cache-Control"]
     end
diff --git a/actionpack/test/controller/parameter_encoding_test.rb b/actionpack/test/controller/parameter_encoding_test.rb
index 7840b4f5c4..234d0bddd1 100644
--- a/actionpack/test/controller/parameter_encoding_test.rb
+++ b/actionpack/test/controller/parameter_encoding_test.rb
@@ -1,9 +1,8 @@
 require "abstract_unit"
 
 class ParameterEncodingController < ActionController::Base
-  parameter_encoding :test_bar,          :bar, Encoding::ASCII_8BIT
-  parameter_encoding :test_baz,          :baz, Encoding::ISO_8859_1
-  parameter_encoding :test_baz_to_ascii, :baz, Encoding::ASCII_8BIT
+  skip_parameter_encoding :test_bar
+  skip_parameter_encoding :test_all_values_encoding
 
   def test_foo
     render body: params[:foo].encoding
@@ -13,16 +12,8 @@ class ParameterEncodingController < ActionController::Base
     render body: params[:bar].encoding
   end
 
-  def test_baz
-    render body: params[:baz].encoding
-  end
-
-  def test_no_change_to_baz
-    render body: params[:baz].encoding
-  end
-
-  def test_baz_to_ascii
-    render body: params[:baz].encoding
+  def test_all_values_encoding
+    render body: ::JSON.dump(params.values.map(&:encoding).map(&:name))
   end
 end
 
@@ -36,32 +27,18 @@ class ParameterEncodingTest < ActionController::TestCase
     assert_equal "UTF-8", @response.body
   end
 
-  test "properly transcodes ASCII_8BIT parameters into declared encodings" do
+  test "properly encodes ASCII_8BIT parameters into binary" do
     post :test_bar, params: { "foo" => "foo", "bar" => "bar", "baz" => "baz" }
 
     assert_response :success
     assert_equal "ASCII-8BIT", @response.body
   end
 
-  test "properly transcodes ISO_8859_1 parameters into declared encodings" do
-    post :test_baz, params: { "foo" => "foo", "bar" => "bar", "baz" => "baz" }
-
-    assert_response :success
-    assert_equal "ISO-8859-1", @response.body
-  end
-
-  test "does not transcode parameters when not specified" do
-    post :test_no_change_to_baz, params: { "foo" => "foo", "bar" => "bar", "baz" => "baz" }
+  test "properly encodes all ASCII_8BIT parameters into binary" do
+    post :test_all_values_encoding, params: { "foo" => "foo", "bar" => "bar", "baz" => "baz" }
 
     assert_response :success
-    assert_equal "UTF-8", @response.body
-  end
-
-  test "respects different encoding declarations for a param per action" do
-    post :test_baz_to_ascii, params: { "foo" => "foo", "bar" => "bar", "baz" => "baz" }
-
-    assert_response :success
-    assert_equal "ASCII-8BIT", @response.body
+    assert_equal ["ASCII-8BIT"], JSON.parse(@response.body).uniq
   end
 
   test "does not raise an error when passed a param declared as ASCII-8BIT that contains invalid bytes" do
diff --git a/actionpack/test/controller/parameters/mutators_test.rb b/actionpack/test/controller/parameters/mutators_test.rb
index e060e5180f..e61bbdbe13 100644
--- a/actionpack/test/controller/parameters/mutators_test.rb
+++ b/actionpack/test/controller/parameters/mutators_test.rb
@@ -45,11 +45,11 @@ class ParametersMutatorsTest < ActiveSupport::TestCase
 
   test "keep_if retains permitted status" do
     @params.permit!
-    assert @params.keep_if { |k,v| k == "person" }.permitted?
+    assert @params.keep_if { |k, v| k == "person" }.permitted?
   end
 
   test "keep_if retains unpermitted status" do
-    assert_not @params.keep_if { |k,v| k == "person" }.permitted?
+    assert_not @params.keep_if { |k, v| k == "person" }.permitted?
   end
 
   test "reject! retains permitted status" do
diff --git a/actionpack/test/controller/parameters/parameters_permit_test.rb b/actionpack/test/controller/parameters/parameters_permit_test.rb
index 728d8e1279..b62a3d6d7b 100644
--- a/actionpack/test/controller/parameters/parameters_permit_test.rb
+++ b/actionpack/test/controller/parameters/parameters_permit_test.rb
@@ -28,7 +28,7 @@ class ParametersPermitTest < ActiveSupport::TestCase
   end
 
   def walk_permitted(params)
-    params.each do |k,v|
+    params.each do |k, v|
       case v
       when ActionController::Parameters
         walk_permitted v
@@ -39,13 +39,13 @@ class ParametersPermitTest < ActiveSupport::TestCase
   end
 
   test "iteration should not impact permit" do
-    hash = { "foo"=>{ "bar"=>{ "0"=>{ "baz"=>"hello", "zot"=>"1" } } } }
+    hash = { "foo" => { "bar" => { "0" => { "baz" => "hello", "zot" => "1" } } } }
     params = ActionController::Parameters.new(hash)
 
     walk_permitted params
 
     sanitized = params[:foo].permit(bar: [:baz])
-    assert_equal({ "0"=>{ "baz"=>"hello" } }, sanitized[:bar].to_unsafe_h)
+    assert_equal({ "0" => { "baz" => "hello" } }, sanitized[:bar].to_unsafe_h)
   end
 
   test "if nothing is permitted, the hash becomes empty" do
@@ -141,7 +141,7 @@ class ParametersPermitTest < ActiveSupport::TestCase
     permitted = params.permit(:a, c: [], b: [])
     assert_equal 1, permitted[:a]
     assert_equal [1, 2, 3], permitted[:b]
-    assert_equal nil, permitted[:c]
+    assert_nil permitted[:c]
   end
 
   test "key to empty array: arrays of permitted scalars pass" do
@@ -168,6 +168,44 @@ class ParametersPermitTest < ActiveSupport::TestCase
     end
   end
 
+  test "key to empty hash: arbitrary hashes are permitted" do
+    params = ActionController::Parameters.new(
+      username: "fxn",
+      preferences: {
+        scheme: "Marazul",
+        font: {
+          name: "Source Code Pro",
+          size: 12
+        },
+        tabstops:   [4, 8, 12, 16],
+        suspicious: [true, Object.new, false, /yo!/],
+        dubious:    [{ a: :a, b: /wtf!/ }, { c: :c }],
+        injected:   Object.new
+      },
+      hacked: 1 # not a hash
+    )
+
+    permitted = params.permit(:username, preferences: {}, hacked: {})
+
+    assert permitted.permitted?
+    assert permitted[:preferences].permitted?
+    assert permitted[:preferences][:font].permitted?
+    assert permitted[:preferences][:dubious].all?(&:permitted?)
+
+    assert_equal "fxn",             permitted[:username]
+    assert_equal "Marazul",         permitted[:preferences][:scheme]
+    assert_equal "Source Code Pro", permitted[:preferences][:font][:name]
+    assert_equal 12,                permitted[:preferences][:font][:size]
+    assert_equal [4, 8, 12, 16],    permitted[:preferences][:tabstops]
+    assert_equal [true, false],     permitted[:preferences][:suspicious]
+    assert_equal :a,                permitted[:preferences][:dubious][0][:a]
+    assert_equal :c,                permitted[:preferences][:dubious][1][:c]
+
+    assert_filtered_out permitted[:preferences][:dubious][0], :b
+    assert_filtered_out permitted[:preferences], :injected
+    assert_filtered_out permitted, :hacked
+  end
+
   test "fetch raises ParameterMissing exception" do
     e = assert_raises(ActionController::ParameterMissing) do
       @params.fetch :foo
@@ -178,7 +216,7 @@ class ParametersPermitTest < ActiveSupport::TestCase
   test "fetch with a default value of a hash does not mutate the object" do
     params = ActionController::Parameters.new({})
     params.fetch :foo, {}
-    assert_equal nil, params[:foo]
+    assert_nil params[:foo]
   end
 
   test "hashes in array values get wrapped" do
@@ -216,8 +254,8 @@ class ParametersPermitTest < ActiveSupport::TestCase
   end
 
   test "fetch doesnt raise ParameterMissing exception if there is a default that is nil" do
-    assert_equal nil, @params.fetch(:foo, nil)
-    assert_equal nil, @params.fetch(:foo) { nil }
+    assert_nil @params.fetch(:foo, nil)
+    assert_nil @params.fetch(:foo) { nil }
   end
 
   test "KeyError in fetch block should not be covered up" do
@@ -244,6 +282,23 @@ class ParametersPermitTest < ActiveSupport::TestCase
     assert merged_params[:id]
   end
 
+  test "not permitted is sticky beyond merge!" do
+    assert_not @params.merge!(a: "b").permitted?
+  end
+
+  test "permitted is sticky beyond merge!" do
+    @params.permit!
+    assert @params.merge!(a: "b").permitted?
+  end
+
+  test "merge! with parameters" do
+    other_params = ActionController::Parameters.new(id: "1234").permit!
+    @params.merge!(other_params)
+
+    assert_equal "1234", @params[:id]
+    assert_equal "32", @params[:person][:age]
+  end
+
   test "modifying the parameters" do
     @params[:person][:hometown] = "Chicago"
     @params[:person][:family] = { brother: "Jonas" }
@@ -322,8 +377,8 @@ class ParametersPermitTest < ActiveSupport::TestCase
   end
 
   test "to_unsafe_h returns unfiltered params even after accessing few keys" do
-    params = ActionController::Parameters.new("f"=>{ "language_facet"=>["Tibetan"] })
-    expected = { "f"=>{ "language_facet"=>["Tibetan"] } }
+    params = ActionController::Parameters.new("f" => { "language_facet" => ["Tibetan"] })
+    expected = { "f" => { "language_facet" => ["Tibetan"] } }
 
     assert params["f"].is_a? ActionController::Parameters
     assert_equal expected, params.to_unsafe_h
diff --git a/actionpack/test/controller/parameters/serialization_test.rb b/actionpack/test/controller/parameters/serialization_test.rb
index 4fb1564c68..6fba2fde91 100644
--- a/actionpack/test/controller/parameters/serialization_test.rb
+++ b/actionpack/test/controller/parameters/serialization_test.rb
@@ -14,12 +14,10 @@ class ParametersSerializationTest < ActiveSupport::TestCase
 
   test "yaml serialization" do
     params = ActionController::Parameters.new(key: :value)
-    assert_equal <<-end_of_yaml.strip_heredoc, YAML.dump(params)
-      --- !ruby/object:ActionController::Parameters
-      parameters: !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-        key: :value
-      permitted: false
-    end_of_yaml
+    yaml_dump = YAML.dump(params)
+    assert_match("--- !ruby/object:ActionController::Parameters", yaml_dump)
+    assert_match(/parameters: !ruby\/hash:ActiveSupport::HashWithIndifferentAccess\n\s+key: :value/, yaml_dump)
+    assert_match("permitted: false", yaml_dump)
   end
 
   test "yaml deserialization" do
diff --git a/actionpack/test/controller/params_wrapper_test.rb b/actionpack/test/controller/params_wrapper_test.rb
index 1549405fe7..faa57c4559 100644
--- a/actionpack/test/controller/params_wrapper_test.rb
+++ b/actionpack/test/controller/params_wrapper_test.rb
@@ -50,7 +50,7 @@ class ParamsWrapperTest < ActionController::TestCase
     with_default_wrapper_options do
       @request.env["CONTENT_TYPE"] = "application/json"
       post :parse, params: { "username" => "sikachu" }
-      assert_equal @request.filtered_parameters, "controller" => "params_wrapper_test/users", "action" => "parse", "username" => "sikachu", "user" => { "username" => "sikachu" }
+      assert_equal({ "controller" => "params_wrapper_test/users", "action" => "parse", "username" => "sikachu", "user" => { "username" => "sikachu" } }, @request.filtered_parameters)
     end
   end
 
@@ -212,6 +212,16 @@ class ParamsWrapperTest < ActionController::TestCase
       )
     end
   end
+
+  def test_handles_empty_content_type
+    with_default_wrapper_options do
+      @request.env["CONTENT_TYPE"] = nil
+      _controller_class.dispatch(:parse, @request, @response)
+
+      assert_equal 200, @response.status
+      assert_equal "", @response.body
+    end
+  end
 end
 
 class NamespacedParamsWrapperTest < ActionController::TestCase
diff --git a/actionpack/test/controller/redirect_test.rb b/actionpack/test/controller/redirect_test.rb
index 0e61b92bcf..e4e968dfdb 100644
--- a/actionpack/test/controller/redirect_test.rb
+++ b/actionpack/test/controller/redirect_test.rb
@@ -123,7 +123,7 @@ class RedirectController < ActionController::Base
 
   def rescue_errors(e) raise e end
 
-  protected
+  private
     def dashbord_url(id, message)
       url_for action: "dashboard", params: { "id" => id, "message" => message }
     end
diff --git a/actionpack/test/controller/render_json_test.rb b/actionpack/test/controller/render_json_test.rb
index 213829bd9e..79552ec8f1 100644
--- a/actionpack/test/controller/render_json_test.rb
+++ b/actionpack/test/controller/render_json_test.rb
@@ -5,7 +5,7 @@ require "pathname"
 
 class RenderJsonTest < ActionController::TestCase
   class JsonRenderable
-    def as_json(options={})
+    def as_json(options = {})
       hash = { a: :b, c: :d, e: :f }
       hash.except!(*options[:except]) if options[:except]
       hash
diff --git a/actionpack/test/controller/render_test.rb b/actionpack/test/controller/render_test.rb
index 76139d59e2..0c0f18f200 100644
--- a/actionpack/test/controller/render_test.rb
+++ b/actionpack/test/controller/render_test.rb
@@ -368,7 +368,7 @@ class ExpiresInRenderTest < ActionController::TestCase
   end
 
   def test_date_header_when_expires_in
-    time = Time.mktime(2011,10,30)
+    time = Time.mktime(2011, 10, 30)
     Time.stub :now, time do
       get :conditional_hello_with_expires_in
       assert_equal Time.now.httpdate, @response.headers["Date"]
diff --git a/actionpack/test/controller/renderer_test.rb b/actionpack/test/controller/renderer_test.rb
index d6f09f2d90..866600b935 100644
--- a/actionpack/test/controller/renderer_test.rb
+++ b/actionpack/test/controller/renderer_test.rb
@@ -60,6 +60,14 @@ class RendererTest < ActiveSupport::TestCase
     assert_equal "true", content
   end
 
+  test "rendering with custom env using a key that is not in RACK_KEY_TRANSLATION" do
+    value    = "warden is here"
+    renderer = ApplicationController.renderer.new warden: value
+    content  = renderer.render inline: "<%= request.env['warden'] %>"
+
+    assert_equal value, content
+  end
+
   test "rendering with defaults" do
     renderer = ApplicationController.renderer.new https: true
     content = renderer.render inline: "<%= request.ssl? %>"
diff --git a/actionpack/test/controller/renderers_test.rb b/actionpack/test/controller/renderers_test.rb
index 122f5be549..ccc700d79c 100644
--- a/actionpack/test/controller/renderers_test.rb
+++ b/actionpack/test/controller/renderers_test.rb
@@ -10,7 +10,7 @@ class RenderersTest < ActionController::TestCase
     end
   end
   class JsonRenderable
-    def as_json(options={})
+    def as_json(options = {})
       hash = { a: :b, c: :d, e: :f }
       hash.except!(*options[:except]) if options[:except]
       hash
diff --git a/actionpack/test/controller/request/test_request_test.rb b/actionpack/test/controller/request/test_request_test.rb
index fa049fbc9f..b67ae72c0a 100644
--- a/actionpack/test/controller/request/test_request_test.rb
+++ b/actionpack/test/controller/request/test_request_test.rb
@@ -8,7 +8,17 @@ class ActionController::TestRequestTest < ActionController::TestCase
 
   def test_mutating_session_options_does_not_affect_default_options
     @request.session_options[:myparam] = 123
-    assert_equal nil, ActionController::TestSession::DEFAULT_OPTIONS[:myparam]
+    assert_nil ActionController::TestSession::DEFAULT_OPTIONS[:myparam]
+  end
+
+  def test_content_length_has_bytes_count_value
+    non_ascii_parameters = { data: { content: "Latin + Кириллица" } }
+    @request.set_header "REQUEST_METHOD", "POST"
+    @request.set_header "CONTENT_TYPE", "application/json"
+    @request.assign_parameters(@routes, "test", "create", non_ascii_parameters,
+                               "/test", [:data, :controller, :action])
+    assert_equal(StringIO.new(non_ascii_parameters.to_json).length.to_s,
+                 @request.get_header("CONTENT_LENGTH"))
   end
 
   ActionDispatch::Session::AbstractStore::DEFAULT_OPTIONS.each_key do |option|
diff --git a/actionpack/test/controller/request_forgery_protection_test.rb b/actionpack/test/controller/request_forgery_protection_test.rb
index 90d5ab3c67..d645ddfdbe 100644
--- a/actionpack/test/controller/request_forgery_protection_test.rb
+++ b/actionpack/test/controller/request_forgery_protection_test.rb
@@ -92,7 +92,7 @@ class PrependProtectForgeryBaseController < ActionController::Base
     render inline: "OK"
   end
 
-  protected
+  private
 
     def add_called_callback(name)
       @called_callbacks ||= []
diff --git a/actionpack/test/controller/rescue_test.rb b/actionpack/test/controller/rescue_test.rb
index a98e6479b7..9ae22c4554 100644
--- a/actionpack/test/controller/rescue_test.rb
+++ b/actionpack/test/controller/rescue_test.rb
@@ -149,7 +149,7 @@ class RescueController < ActionController::Base
     raise RangeError
   end
 
-  protected
+  private
     def deny_access
       head :forbidden
     end
@@ -327,7 +327,7 @@ class RescueTest < ActionDispatch::IntegrationTest
       raise "b00m"
     end
 
-    protected
+    private
       def show_errors(exception)
         render plain: exception.message
       end
diff --git a/actionpack/test/controller/resources_test.rb b/actionpack/test/controller/resources_test.rb
index b572e7e8d5..fad34dacce 100644
--- a/actionpack/test/controller/resources_test.rb
+++ b/actionpack/test/controller/resources_test.rb
@@ -27,7 +27,7 @@ class ResourcesTest < ActionController::TestCase
 
   def test_override_paths_for_member_and_collection_methods
     collection_methods = { rss: :get, reorder: :post, csv: :post }
-    member_methods    = { rss: :get, atom: :get, upload: :post, fix: :post }
+    member_methods = { rss: :get, atom: :get, upload: :post, fix: :post }
     path_names = { new: "nuevo", rss: "canal", fix: "corrigir" }
 
     with_restful_routing :messages,
@@ -792,7 +792,7 @@ class ResourcesTest < ActionController::TestCase
       end
 
       assert_simply_restful_for :product_reviews, controller: "messages", as: "reviews", name_prefix: "product_", path_prefix: "products/1/", options: { product_id: "1" }
-      assert_simply_restful_for :tutor_reviews,controller: "comments", as: "reviews", name_prefix: "tutor_", path_prefix: "tutors/1/", options: { tutor_id: "1" }
+      assert_simply_restful_for :tutor_reviews, controller: "comments", as: "reviews", name_prefix: "tutor_", path_prefix: "tutors/1/", options: { tutor_id: "1" }
     end
   end
 
@@ -1089,7 +1089,7 @@ class ResourcesTest < ActionController::TestCase
     end
   end
 
-  protected
+  private
     def with_restful_routing(*args)
       options = args.extract_options!
       collection_methods = options.delete(:collection)
@@ -1306,7 +1306,7 @@ class ResourcesTest < ActionController::TestCase
     end
 
     def assert_named_route(expected, route, options)
-      actual =  @controller.send(route, options) rescue $!.class.name
+      actual = @controller.send(route, options) rescue $!.class.name
       assert_equal expected, actual, "Error on route: #{route}(#{options.inspect})"
     end
 
diff --git a/actionpack/test/controller/routing_test.rb b/actionpack/test/controller/routing_test.rb
index 7be2ad2b28..56b39510bb 100644
--- a/actionpack/test/controller/routing_test.rb
+++ b/actionpack/test/controller/routing_test.rb
@@ -91,7 +91,7 @@ class LegacyRouteSetTests < ActiveSupport::TestCase
     end
 
     hash = ActiveSupport::JSON.decode get(URI("http://example.org/journey/faithfully-omg"))
-    assert_equal({ "artist"=>"journey", "song"=>"faithfully" }, hash)
+    assert_equal({ "artist" => "journey", "song" => "faithfully" }, hash)
   end
 
   def test_id_with_dash
@@ -103,7 +103,7 @@ class LegacyRouteSetTests < ActiveSupport::TestCase
     end
 
     hash = ActiveSupport::JSON.decode get(URI("http://example.org/journey/faithfully-omg"))
-    assert_equal({ "id"=>"faithfully-omg" }, hash)
+    assert_equal({ "id" => "faithfully-omg" }, hash)
   end
 
   def test_dash_with_custom_regexp
@@ -115,7 +115,7 @@ class LegacyRouteSetTests < ActiveSupport::TestCase
     end
 
     hash = ActiveSupport::JSON.decode get(URI("http://example.org/journey/123-omg"))
-    assert_equal({ "artist"=>"journey", "song"=>"123" }, hash)
+    assert_equal({ "artist" => "journey", "song" => "123" }, hash)
     assert_equal "Not Found", get(URI("http://example.org/journey/faithfully-omg"))
   end
 
@@ -128,7 +128,7 @@ class LegacyRouteSetTests < ActiveSupport::TestCase
     end
 
     hash = ActiveSupport::JSON.decode get(URI("http://example.org/journey/omg-faithfully"))
-    assert_equal({ "artist"=>"journey", "song"=>"faithfully" }, hash)
+    assert_equal({ "artist" => "journey", "song" => "faithfully" }, hash)
   end
 
   def test_pre_dash_with_custom_regexp
@@ -140,7 +140,7 @@ class LegacyRouteSetTests < ActiveSupport::TestCase
     end
 
     hash = ActiveSupport::JSON.decode get(URI("http://example.org/journey/omg-123"))
-    assert_equal({ "artist"=>"journey", "song"=>"123" }, hash)
+    assert_equal({ "artist" => "journey", "song" => "123" }, hash)
     assert_equal "Not Found", get(URI("http://example.org/journey/omg-faithfully"))
   end
 
@@ -1931,7 +1931,7 @@ class RackMountIntegrationTests < ActiveSupport::TestCase
     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 => {
+    get "extended/geocode/:postalcode" => "geocode#show", :constraints => {
                   postalcode: /# Postcode format
                                   \d{5} #Prefix
                                   (-\d{4})? #Suffix
diff --git a/actionpack/test/controller/send_file_test.rb b/actionpack/test/controller/send_file_test.rb
index 8dc565ac8d..9e6b975fe2 100644
--- a/actionpack/test/controller/send_file_test.rb
+++ b/actionpack/test/controller/send_file_test.rb
@@ -180,7 +180,7 @@ class SendFileTest < ActionController::TestCase
       "file.zip" => "application/zip",
       "file.unk" => "application/octet-stream",
       "zip" => "application/octet-stream"
-    }.each do |filename,expected_type|
+    }.each do |filename, expected_type|
       get __method__, params: { filename: filename }
       assert_equal expected_type, response.content_type
     end
@@ -241,10 +241,17 @@ class SendFileTest < ActionController::TestCase
     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; charset=utf-8", response.headers["Content-Type"]
+    assert_equal "text/calendar", response.headers["Content-Type"]
   end
 end
diff --git a/actionpack/test/controller/test_case_test.rb b/actionpack/test/controller/test_case_test.rb
index 82f42e306f..874f9c3c42 100644
--- a/actionpack/test/controller/test_case_test.rb
+++ b/actionpack/test/controller/test_case_test.rb
@@ -100,11 +100,11 @@ HTML
     end
 
     def test_xml_output
-      response.content_type = "application/xml"
+      response.content_type = params[:response_as]
       render plain: <<XML
 <?xml version="1.0" encoding="UTF-8"?>
 <root>
-  <area>area is an empty tag in HTML, raising an error if not in xml mode</area>
+  <area><p>area is an empty tag in HTML, so it won't contain this content</p></area>
 </root>
 XML
     end
@@ -231,7 +231,7 @@ XML
 
   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))
+    assert_equal({ "id" => "1", "controller" => "test_case_test/test", "action" => "test_params" }, ::JSON.parse(@response.body))
   end
 
   def test_document_body_with_post
@@ -374,18 +374,18 @@ XML
     assert_equal "OK", @response.body
   end
 
-  def test_should_not_impose_childless_html_tags_in_xml
-    process :test_xml_output
+  def test_should_impose_childless_html_tags_in_html
+    process :test_xml_output, params: { response_as: "text/html" }
 
-    begin
-      $stderr = StringIO.new
-      assert_select "area" #This will cause a warning if content is processed as HTML
-      $stderr.rewind && err = $stderr.read
-    ensure
-      $stderr = STDERR
-    end
+    # <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" }
 
-    assert err.empty?
+    # <area> is not special, so the <p> is its child
+    assert_select "root > area > p"
   end
 
   def test_assert_generates
@@ -651,7 +651,7 @@ XML
   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))
+    assert_equal({ "id" => "1", "controller" => "test_case_test/test", "action" => "test_params" }, ::JSON.parse(@response.body))
   end
 
   def test_xhr_with_session
@@ -753,10 +753,10 @@ XML
 
   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))
+    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))
+    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|
@@ -781,7 +781,7 @@ XML
   READ_PLAIN = "r:binary"
 
   def test_test_uploaded_file
-    filename = "mona_lisa.jpg"
+    filename = "ruby_on_rails.jpg"
     path = "#{FILES_DIR}/#{filename}"
     content_type = "image/png"
     expected = File.read(path)
@@ -801,13 +801,13 @@ XML
 
   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("/mona_lisa.jpg", "image/png")
-      assert_equal File.open("#{FILES_DIR}/mona_lisa.jpg", READ_PLAIN).read, uploaded_file.read
+      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 = "mona_lisa.jpg"
+    filename = "ruby_on_rails.jpg"
     path = "#{FILES_DIR}/#{filename}"
     content_type = "image/png"
 
@@ -819,7 +819,7 @@ XML
   end
 
   def test_fixture_file_upload_with_binary
-    filename = "mona_lisa.jpg"
+    filename = "ruby_on_rails.jpg"
     path = "#{FILES_DIR}/#{filename}"
     content_type = "image/jpg"
 
@@ -831,44 +831,44 @@ XML
   end
 
   def test_fixture_file_upload_should_be_able_access_to_tempfile
-    file = fixture_file_upload(FILES_DIR + "/mona_lisa.jpg", "image/jpg")
+    file = fixture_file_upload(FILES_DIR + "/ruby_on_rails.jpg", "image/jpg")
     assert file.respond_to?(:tempfile), "expected tempfile should respond on fixture file object, got nothing"
   end
 
   def test_fixture_file_upload
     post :test_file_upload,
       params: {
-        file: fixture_file_upload(FILES_DIR + "/mona_lisa.jpg", "image/jpg")
+        file: fixture_file_upload(FILES_DIR + "/ruby_on_rails.jpg", "image/jpg")
       }
-    assert_equal "159528", @response.body
+    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("mona_lisa.jpg", "image/jpg")
-      assert_equal File.open("#{FILES_DIR}/mona_lisa.jpg", READ_PLAIN).read, uploaded_file.read
+      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, File.dirname(__FILE__) do
-      uploaded_file = fixture_file_upload("#{FILES_DIR}/mona_lisa.jpg", "image/jpg")
-      assert_equal File.open("#{FILES_DIR}/mona_lisa.jpg", READ_PLAIN).read, uploaded_file.read
+      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}/mona_lisa.jpg", "image/jpg")
-    assert_equal File.open("#{FILES_DIR}/mona_lisa.jpg", READ_PLAIN).read, uploaded_file.read
+    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 = "mona_lisa.jpg"
+    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 "159528", @response.body
+    assert_equal "45142", @response.body
   end
 
   def test_test_uploaded_file_exception_when_file_doesnt_exist
diff --git a/actionpack/test/controller/url_for_integration_test.rb b/actionpack/test/controller/url_for_integration_test.rb
index c7ea6c5ef6..f640e77b99 100644
--- a/actionpack/test/controller/url_for_integration_test.rb
+++ b/actionpack/test/controller/url_for_integration_test.rb
@@ -43,7 +43,7 @@ module ActionPack
       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 => {
+      get "extended/geocode/:postalcode" => "geocode#show", :constraints => {
         postalcode: /# Postcode format
         \d{5} #Prefix
         (-\d{4})? #Suffix
@@ -73,99 +73,99 @@ module ActionPack
     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" }]],
+      ["/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" } } }]],
diff --git a/actionpack/test/controller/url_for_test.rb b/actionpack/test/controller/url_for_test.rb
index 8d7190365d..4b6f33c545 100644
--- a/actionpack/test/controller/url_for_test.rb
+++ b/actionpack/test/controller/url_for_test.rb
@@ -223,13 +223,13 @@ module AbstractController
       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) )
+        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) )
+        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
 
@@ -238,7 +238,7 @@ module AbstractController
         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))
+        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
@@ -423,7 +423,7 @@ module AbstractController
         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 first_host, first_class.default_url_options[:host]
         assert_equal second_host, second_class.default_url_options[:host]
       end
 
diff --git a/actionpack/test/dispatch/cookies_test.rb b/actionpack/test/dispatch/cookies_test.rb
index 6dcd62572a..664faa31bb 100644
--- a/actionpack/test/dispatch/cookies_test.rb
+++ b/actionpack/test/dispatch/cookies_test.rb
@@ -43,7 +43,7 @@ class CookieJarTest < ActiveSupport::TestCase
   def test_each
     request.cookie_jar["foo"] = :bar
     list = []
-    request.cookie_jar.each do |k,v|
+    request.cookie_jar.each do |k, v|
       list << [k, v]
     end
 
@@ -52,7 +52,7 @@ class CookieJarTest < ActiveSupport::TestCase
 
   def test_enumerable
     request.cookie_jar["foo"] = :bar
-    actual = request.cookie_jar.map { |k,v| [k.to_s, v.to_s] }
+    actual = request.cookie_jar.map { |k, v| [k.to_s, v.to_s] }
     assert_equal [["foo", "bar"]], actual
   end
 
@@ -95,17 +95,17 @@ class CookiesTest < ActionController::TestCase
     end
 
     def authenticate_for_fourteen_days
-      cookies["user_name"] = { "value" => "david", "expires" => Time.utc(2005, 10, 10,5) }
+      cookies["user_name"] = { "value" => "david", "expires" => Time.utc(2005, 10, 10, 5) }
       head :ok
     end
 
     def authenticate_for_fourteen_days_with_symbols
-      cookies[:user_name] = { value: "david", expires: Time.utc(2005, 10, 10,5) }
+      cookies[:user_name] = { value: "david", expires: Time.utc(2005, 10, 10, 5) }
       head :ok
     end
 
     def set_multiple_cookies
-      cookies["user_name"] = { "value" => "david", "expires" => Time.utc(2005, 10, 10,5) }
+      cookies["user_name"] = { "value" => "david", "expires" => Time.utc(2005, 10, 10, 5) }
       cookies["login"]     = "XJ-122"
       head :ok
     end
@@ -205,7 +205,7 @@ class CookiesTest < ActionController::TestCase
 
     def delete_and_set_cookie
       cookies.delete :user_name
-      cookies[:user_name] = { value: "david", expires: Time.utc(2005, 10, 10,5) }
+      cookies[:user_name] = { value: "david", expires: Time.utc(2005, 10, 10, 5) }
       head :ok
     end
 
@@ -272,6 +272,10 @@ class CookiesTest < ActionController::TestCase
     def noop
       head :ok
     end
+
+    def encrypted_cookie
+      cookies.encrypted["foo"]
+    end
   end
 
   tests TestController
@@ -940,8 +944,8 @@ class CookiesTest < ActionController::TestCase
     @request.headers["Cookie"] = "user_id=45"
     get :get_signed_cookie
 
-    assert_equal nil, @controller.send(:cookies).signed[:user_id]
-    assert_equal nil, @response.cookies["user_id"]
+    assert_nil @controller.send(:cookies).signed[:user_id]
+    assert_nil @response.cookies["user_id"]
   end
 
   def test_legacy_signed_cookie_is_treated_as_nil_by_encrypted_cookie_jar_if_tampered
@@ -951,8 +955,8 @@ class CookiesTest < ActionController::TestCase
     @request.headers["Cookie"] = "foo=baz"
     get :get_encrypted_cookie
 
-    assert_equal nil, @controller.send(:cookies).encrypted[:foo]
-    assert_equal nil, @response.cookies["foo"]
+    assert_nil @controller.send(:cookies).encrypted[:foo]
+    assert_nil @response.cookies["foo"]
   end
 
   def test_cookie_with_all_domain_option
@@ -1189,6 +1193,12 @@ class CookiesTest < ActionController::TestCase
     assert_equal "david", cookies[:user_name]
   end
 
+  def test_cookies_are_not_cleared
+    cookies.encrypted["foo"] = "bar"
+    get :noop
+    assert_equal "bar", @controller.encrypted_cookie
+  end
+
   private
     def assert_cookie_header(expected)
       header = @response.headers["Set-Cookie"]
diff --git a/actionpack/test/dispatch/debug_exceptions_test.rb b/actionpack/test/dispatch/debug_exceptions_test.rb
index 2c5e09e283..ea477e8908 100644
--- a/actionpack/test/dispatch/debug_exceptions_test.rb
+++ b/actionpack/test/dispatch/debug_exceptions_test.rb
@@ -287,7 +287,7 @@ class DebugExceptionsTest < ActionDispatch::IntegrationTest
   test "does not show filtered parameters" do
     @app = DevelopmentApp
 
-    get "/", params: { "foo"=>"bar" }, headers: { "action_dispatch.show_exceptions" => true,
+    get "/", params: { "foo" => "bar" }, headers: { "action_dispatch.show_exceptions" => true,
       "action_dispatch.parameter_filter" => [:foo] }
     assert_response 500
     assert_match("&quot;foo&quot;=&gt;&quot;[FILTERED]&quot;", body)
@@ -384,6 +384,23 @@ class DebugExceptionsTest < ActionDispatch::IntegrationTest
     end
   end
 
+  test "logs with non active support loggers" do
+    @app = DevelopmentApp
+    io = StringIO.new
+    logger = Logger.new(io)
+
+    _old, ActionView::Base.logger = ActionView::Base.logger, logger
+    begin
+      assert_nothing_raised do
+        get "/", headers: { "action_dispatch.show_exceptions" => true, "action_dispatch.logger" => logger }
+      end
+    ensure
+      ActionView::Base.logger = _old
+    end
+
+    assert_match(/puke/, io.rewind && io.read)
+  end
+
   test "uses backtrace cleaner from env" do
     @app = DevelopmentApp
     backtrace_cleaner = ActiveSupport::BacktraceCleaner.new
diff --git a/actionpack/test/dispatch/header_test.rb b/actionpack/test/dispatch/header_test.rb
index 6febd5cb68..958450072e 100644
--- a/actionpack/test/dispatch/header_test.rb
+++ b/actionpack/test/dispatch/header_test.rb
@@ -155,8 +155,8 @@ class HeaderTest < ActiveSupport::TestCase
     headers = make_headers(env)
     headers["Referer"] = "http://example.com/"
     headers.merge! "CONTENT_TYPE" => "text/plain"
-    assert_equal({ "HTTP_REFERER"=>"http://example.com/",
-                  "CONTENT_TYPE"=>"text/plain" }, env)
+    assert_equal({ "HTTP_REFERER" => "http://example.com/",
+                  "CONTENT_TYPE" => "text/plain" }, env)
   end
 
   test "fetch exception" do
diff --git a/actionpack/test/dispatch/mime_type_test.rb b/actionpack/test/dispatch/mime_type_test.rb
index e558efb88d..2ca03c535a 100644
--- a/actionpack/test/dispatch/mime_type_test.rb
+++ b/actionpack/test/dispatch/mime_type_test.rb
@@ -89,7 +89,7 @@ class MimeTypeTest < ActiveSupport::TestCase
   #  (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; InfoPath.1)
   test "parse other broken acceptlines" do
     accept = "image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword,  , pronto/1.00.00, sslvpn/1.00.00.00, */*"
-    expect = ["image/gif", "image/x-xbitmap", "image/jpeg","image/pjpeg", "application/x-shockwave-flash", "application/vnd.ms-excel", "application/vnd.ms-powerpoint", "application/msword", "pronto/1.00.00", "sslvpn/1.00.00.00", "*/*"]
+    expect = ["image/gif", "image/x-xbitmap", "image/jpeg", "image/pjpeg", "application/x-shockwave-flash", "application/vnd.ms-excel", "application/vnd.ms-powerpoint", "application/msword", "pronto/1.00.00", "sslvpn/1.00.00.00", "*/*"]
     assert_equal expect.map(&:to_s), Mime::Type.parse(accept).map(&:to_s)
   end
 
diff --git a/actionpack/test/dispatch/reloader_test.rb b/actionpack/test/dispatch/reloader_test.rb
index e74b8e40fd..db68549b84 100644
--- a/actionpack/test/dispatch/reloader_test.rb
+++ b/actionpack/test/dispatch/reloader_test.rb
@@ -178,7 +178,7 @@ class ReloaderTest < ActiveSupport::TestCase
   def test_cleanup_callbacks_are_called_on_exceptions
     cleaned = false
     assert_deprecated do
-      Reloader.to_cleanup { cleaned  = true }
+      Reloader.to_cleanup { cleaned = true }
     end
 
     begin
diff --git a/actionpack/test/dispatch/request/multipart_params_parsing_test.rb b/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
index e572c722a0..01c5ff1429 100644
--- a/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
@@ -129,7 +129,7 @@ class MultipartParamsParsingTest < ActionDispatch::IntegrationTest
     params = parse_multipart("none")
     assert_equal %w(submit-name), params.keys.sort
     assert_equal "Larry", params["submit-name"]
-    assert_equal nil, params["files"]
+    assert_nil params["files"]
   end
 
   test "parses empty upload file" do
@@ -142,7 +142,7 @@ class MultipartParamsParsingTest < ActionDispatch::IntegrationTest
 
   test "uploads and reads binary file" do
     with_test_routing do
-      fixture = FIXTURE_PATH + "/mona_lisa.jpg"
+      fixture = FIXTURE_PATH + "/ruby_on_rails.jpg"
       params = { uploaded_data: fixture_file_upload(fixture, "image/jpg") }
       post "/read", params: params
     end
diff --git a/actionpack/test/dispatch/request/query_string_parsing_test.rb b/actionpack/test/dispatch/request/query_string_parsing_test.rb
index 5c992be216..2499c33cef 100644
--- a/actionpack/test/dispatch/request/query_string_parsing_test.rb
+++ b/actionpack/test/dispatch/request/query_string_parsing_test.rb
@@ -97,7 +97,7 @@ class QueryStringParsingTest < ActionDispatch::IntegrationTest
     assert_parses({ "action" => { "foo" => { "bar" => nil } } }, "action[foo][bar]")
     assert_parses({ "action" => { "foo" => { "bar" => [] } } }, "action[foo][bar][]")
     assert_parses({ "action" => { "foo" => [] } }, "action[foo][]")
-    assert_parses({ "action"=>{ "foo"=>[{ "bar"=>nil }] } }, "action[foo][][bar]")
+    assert_parses({ "action" => { "foo" => [{ "bar" => nil }] } }, "action[foo][][bar]")
   end
 
   def test_array_parses_without_nil
@@ -114,7 +114,7 @@ class QueryStringParsingTest < ActionDispatch::IntegrationTest
       assert_parses({ "action" => { "foo" => { "bar" => [nil] } } }, "action[foo][bar][]")
       assert_parses({ "action" => { "foo" => [nil] } }, "action[foo][]")
       assert_parses({ "action" => { "foo" => [{ "bar" => nil }] } }, "action[foo][][bar]")
-      assert_parses({ "action" => ["1",nil] }, "action[]=1&action[]")
+      assert_parses({ "action" => ["1", nil] }, "action[]=1&action[]")
     ensure
       ActionDispatch::Request::Utils.perform_deep_munge = old_perform_deep_munge
     end
diff --git a/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb b/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
index 5c7558e48d..1169bf0cdb 100644
--- a/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
@@ -55,7 +55,7 @@ class UrlEncodedParamsParsingTest < ActionDispatch::IntegrationTest
       "products[second]=Pc",
       "=Save"
     ].join("&")
-    expected =  {
+    expected = {
       "customers" => {
         "boston" => {
           "first" => {
diff --git a/actionpack/test/dispatch/request_test.rb b/actionpack/test/dispatch/request_test.rb
index 13a87b8976..e11b93b4f0 100644
--- a/actionpack/test/dispatch/request_test.rb
+++ b/actionpack/test/dispatch/request_test.rb
@@ -18,7 +18,7 @@ class BaseRequestTest < ActiveSupport::TestCase
     ActionDispatch::Http::URL.url_for(options)
   end
 
-  protected
+  private
     def stub_request(env = {})
       ip_spoofing_check = env.key?(:ip_spoofing_check) ? env.delete(:ip_spoofing_check) : true
       @trusted_proxies ||= nil
@@ -94,13 +94,13 @@ class RequestIP < BaseRequestTest
     assert_equal "3.4.5.6", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "unknown,192.168.0.1"
-    assert_equal nil, request.remote_ip
+    assert_nil request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "9.9.9.9, 3.4.5.6, 172.31.4.4, 10.0.0.1"
     assert_equal "3.4.5.6", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "not_ip_address"
-    assert_equal nil, request.remote_ip
+    assert_nil request.remote_ip
   end
 
   test "remote ip spoof detection" do
@@ -154,7 +154,7 @@ class RequestIP < BaseRequestTest
     assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "unknown,::1"
-    assert_equal nil, request.remote_ip
+    assert_nil request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7334, fe80:0000:0000:0000:0202:b3ff:fe1e:8329, ::1, fc00::, fc01::, fdff"
     assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
@@ -163,7 +163,7 @@ class RequestIP < BaseRequestTest
     assert_equal "FE00::", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "not_ip_address"
-    assert_equal nil, request.remote_ip
+    assert_nil request.remote_ip
   end
 
   test "remote ip v6 spoof detection" do
@@ -200,7 +200,7 @@ class RequestIP < BaseRequestTest
     assert_equal "3.4.5.6", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "67.205.106.73,unknown"
-    assert_equal nil, request.remote_ip
+    assert_nil request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "9.9.9.9, 3.4.5.6, 10.0.0.1, 67.205.106.73"
     assert_equal "3.4.5.6", request.remote_ip
@@ -222,7 +222,7 @@ class RequestIP < BaseRequestTest
     assert_equal "::1", request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "unknown,fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
-    assert_equal nil, request.remote_ip
+    assert_nil request.remote_ip
 
     request = stub_request "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329,2001:0db8:85a3:0000:0000:8a2e:0370:7334"
     assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7334", request.remote_ip
@@ -345,7 +345,7 @@ class RequestPort < BaseRequestTest
 
   test "optional port" do
     request = stub_request "HTTP_HOST" => "www.example.org:80"
-    assert_equal nil, request.optional_port
+    assert_nil request.optional_port
 
     request = stub_request "HTTP_HOST" => "www.example.org:8080"
     assert_equal 8080, request.optional_port
@@ -537,7 +537,7 @@ class RequestCGI < BaseRequestTest
 
     assert_equal "Basic", request.auth_type
     assert_equal 0, request.content_length
-    assert_equal nil, request.content_mime_type
+    assert_nil request.content_mime_type
     assert_equal "CGI/1.1", request.gateway_interface
     assert_equal "*/*", request.accept
     assert_equal "UTF-8", request.accept_charset
@@ -581,7 +581,7 @@ class RequestCookie < BaseRequestTest
 
     # some Nokia phone browsers omit the space after the semicolon separator.
     # some developers have grown accustomed to using comma in cookie values.
-    request = stub_request("HTTP_COOKIE"=>"_session_id=c84ace847,96670c052c6ceb2451fb0f2;is_admin=yes")
+    request = stub_request("HTTP_COOKIE" => "_session_id=c84ace847,96670c052c6ceb2451fb0f2;is_admin=yes")
     assert_equal "c84ace847", request.cookies["_session_id"], request.cookies.inspect
     assert_equal "yes", request.cookies["is_admin"], request.cookies.inspect
   end
@@ -596,7 +596,7 @@ class RequestParamsParsing < BaseRequestTest
       "rack.input" => StringIO.new("flamenco=love")
     )
 
-    assert_equal({ "flamenco"=> "love" }, request.request_parameters)
+    assert_equal({ "flamenco" => "love" }, request.request_parameters)
   end
 
   test "doesnt interpret request uri as query string when missing" do
@@ -774,8 +774,8 @@ class RequestMethod < BaseRequestTest
     ensure
       # Reset original acronym set
       ActiveSupport::Inflector.inflections do |inflect|
-        inflect.send(:instance_variable_set,"@acronyms",existing_acrnoyms)
-        inflect.send(:instance_variable_set,"@acronym_regex",existing_acrnoym_regex)
+        inflect.send(:instance_variable_set, "@acronyms", existing_acrnoyms)
+        inflect.send(:instance_variable_set, "@acronym_regex", existing_acrnoym_regex)
       end
     end
   end
@@ -957,7 +957,7 @@ class RequestMimeType < BaseRequestTest
   end
 
   test "no content type" do
-    assert_equal nil, stub_request.content_mime_type
+    assert_nil stub_request.content_mime_type
   end
 
   test "content type is XML" do
@@ -978,7 +978,7 @@ class RequestMimeType < BaseRequestTest
       "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest"
     )
 
-    assert_equal nil, request.negotiate_mime([Mime[:xml], Mime[:json]])
+    assert_nil request.negotiate_mime([Mime[:xml], Mime[:json]])
     assert_equal Mime[:html], request.negotiate_mime([Mime[:xml], Mime[:html]])
     assert_equal Mime[:html], request.negotiate_mime([Mime[:xml], Mime::ALL])
   end
@@ -1072,14 +1072,14 @@ end
 class RequestParameterFilter < BaseRequestTest
   test "process parameter filter" do
     test_hashes = [
-    [{ "foo"=>"bar" },{ "foo"=>"bar" },%w'food'],
-    [{ "foo"=>"bar" },{ "foo"=>"[FILTERED]" },%w'foo'],
-    [{ "foo"=>"bar", "bar"=>"foo" },{ "foo"=>"[FILTERED]", "bar"=>"foo" },%w'foo baz'],
-    [{ "foo"=>"bar", "baz"=>"foo" },{ "foo"=>"[FILTERED]", "baz"=>"[FILTERED]" },%w'foo baz'],
-    [{ "bar"=>{ "foo"=>"bar","bar"=>"foo" } },{ "bar"=>{ "foo"=>"[FILTERED]","bar"=>"foo" } },%w'fo'],
-    [{ "foo"=>{ "foo"=>"bar","bar"=>"foo" } },{ "foo"=>"[FILTERED]" },%w'f banana'],
-    [{ "deep"=>{ "cc"=>{ "code"=>"bar","bar"=>"foo" },"ss"=>{ "code"=>"bar" } } },{ "deep"=>{ "cc"=>{ "code"=>"[FILTERED]","bar"=>"foo" },"ss"=>{ "code"=>"bar" } } },%w'deep.cc.code'],
-    [{ "baz"=>[{ "foo"=>"baz" }, "1"] }, { "baz"=>[{ "foo"=>"[FILTERED]" }, "1"] }, [/foo/]]]
+    [{ "foo" => "bar" }, { "foo" => "bar" }, %w'food'],
+    [{ "foo" => "bar" }, { "foo" => "[FILTERED]" }, %w'foo'],
+    [{ "foo" => "bar", "bar" => "foo" }, { "foo" => "[FILTERED]", "bar" => "foo" }, %w'foo baz'],
+    [{ "foo" => "bar", "baz" => "foo" }, { "foo" => "[FILTERED]", "baz" => "[FILTERED]" }, %w'foo baz'],
+    [{ "bar" => { "foo" => "bar", "bar" => "foo" } }, { "bar" => { "foo" => "[FILTERED]", "bar" => "foo" } }, %w'fo'],
+    [{ "foo" => { "foo" => "bar", "bar" => "foo" } }, { "foo" => "[FILTERED]" }, %w'f banana'],
+    [{ "deep" => { "cc" => { "code" => "bar", "bar" => "foo" }, "ss" => { "code" => "bar" } } }, { "deep" => { "cc" => { "code" => "[FILTERED]", "bar" => "foo" }, "ss" => { "code" => "bar" } } }, %w'deep.cc.code'],
+    [{ "baz" => [{ "foo" => "baz" }, "1"] }, { "baz" => [{ "foo" => "[FILTERED]" }, "1"] }, [/foo/]]]
 
     test_hashes.each do |before_filter, after_filter, filter_words|
       parameter_filter = ActionDispatch::Http::ParameterFilter.new(filter_words)
@@ -1091,8 +1091,8 @@ class RequestParameterFilter < BaseRequestTest
       }
 
       parameter_filter = ActionDispatch::Http::ParameterFilter.new(filter_words)
-      before_filter["barg"] = { :bargain=>"gain", "blah"=>"bar", "bar"=>{ "bargain"=>{ "blah"=>"foo" } } }
-      after_filter["barg"]  = { :bargain=>"niag", "blah"=>"[FILTERED]", "bar"=>{ "bargain"=>{ "blah"=>"[FILTERED]" } } }
+      before_filter["barg"] = { :bargain => "gain", "blah" => "bar", "bar" => { "bargain" => { "blah" => "foo" } } }
+      after_filter["barg"]  = { :bargain => "niag", "blah" => "[FILTERED]", "bar" => { "bargain" => { "blah" => "[FILTERED]" } } }
 
       assert_equal after_filter, parameter_filter.filter(before_filter)
     end
@@ -1192,7 +1192,7 @@ class RequestEtag < BaseRequestTest
   test "doesn't match absent If-None-Match" do
     request = stub_request
 
-    assert_equal nil, request.if_none_match
+    assert_nil request.if_none_match
     assert_equal [], request.if_none_match_etags
 
     assert_not request.etag_matches?("foo")
diff --git a/actionpack/test/dispatch/response_test.rb b/actionpack/test/dispatch/response_test.rb
index 4e547ab7d5..7433c5ce0c 100644
--- a/actionpack/test/dispatch/response_test.rb
+++ b/actionpack/test/dispatch/response_test.rb
@@ -74,7 +74,7 @@ class ResponseTest < ActiveSupport::TestCase
     @response.body = "Hello, World!"
 
     # even though there's no explicitly set content-type,
-    assert_equal nil, @response.content_type
+    assert_nil @response.content_type
 
     # after the action reads back @response.body,
     assert_equal "Hello, World!", @response.body
@@ -110,6 +110,11 @@ class ResponseTest < ActiveSupport::TestCase
     assert_equal "application/aaron", @response.content_type
   end
 
+  def test_empty_content_type_returns_nil
+    @response.headers["Content-Type"] = ""
+    assert_nil @response.content_type
+  end
+
   test "simple output" do
     @response.body = "Hello, World!"
 
@@ -131,7 +136,7 @@ class ResponseTest < ActiveSupport::TestCase
   def test_only_set_charset_still_defaults_to_text_html
     response = ActionDispatch::Response.new
     response.charset = "utf-16"
-    _,headers,_ = response.to_a
+    _, headers, _ = response.to_a
     assert_equal "text/html; charset=utf-16", headers["Content-Type"]
   end
 
@@ -229,7 +234,7 @@ class ResponseTest < ActiveSupport::TestCase
 
   test "multiple cookies" do
     @response.set_cookie("user_name", value: "david", path: "/")
-    @response.set_cookie("login", value: "foo&bar", path: "/", expires: Time.utc(2005, 10, 10,5))
+    @response.set_cookie("login", value: "foo&bar", path: "/", expires: Time.utc(2005, 10, 10, 5))
     _status, headers, _body = @response.to_a
     assert_equal "user_name=david; path=/\nlogin=foo%26bar; path=/; expires=Mon, 10 Oct 2005 05:00:00 -0000", headers["Set-Cookie"]
     assert_equal({ "login" => "foo&bar", "user_name" => "david" }, @response.cookies)
@@ -237,7 +242,7 @@ class ResponseTest < ActiveSupport::TestCase
 
   test "delete cookies" do
     @response.set_cookie("user_name", value: "david", path: "/")
-    @response.set_cookie("login", value: "foo&bar", path: "/", expires: Time.utc(2005, 10, 10,5))
+    @response.set_cookie("login", value: "foo&bar", path: "/", expires: Time.utc(2005, 10, 10, 5))
     @response.delete_cookie("login")
     assert_equal({ "user_name" => "david", "login" => nil }, @response.cookies)
   end
diff --git a/actionpack/test/dispatch/routing/ipv6_redirect_test.rb b/actionpack/test/dispatch/routing/ipv6_redirect_test.rb
index 4987ed84e4..179aee9ba7 100644
--- a/actionpack/test/dispatch/routing/ipv6_redirect_test.rb
+++ b/actionpack/test/dispatch/routing/ipv6_redirect_test.rb
@@ -7,7 +7,7 @@ class IPv6IntegrationTest < ActionDispatch::IntegrationTest
   class ::BadRouteRequestController < ActionController::Base
     include Routes.url_helpers
     def index
-      render text: foo_path
+      render plain: foo_path
     end
 
     def foo
diff --git a/actionpack/test/dispatch/routing_test.rb b/actionpack/test/dispatch/routing_test.rb
index c01065932a..474d053af6 100644
--- a/actionpack/test/dispatch/routing_test.rb
+++ b/actionpack/test/dispatch/routing_test.rb
@@ -1933,7 +1933,7 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
           post :preview, on: :new
         end
 
-        resource  :admin, path_names: { new: "novo" }, path: "administrador" do
+        resource :admin, path_names: { new: "novo" }, path: "administrador" do
           post :preview, on: :new
         end
 
@@ -3736,7 +3736,7 @@ private
     https!(old_https)
   end
 
-  def verify_redirect(url, status=301)
+  def verify_redirect(url, status = 301)
     assert_equal status, @response.status
     assert_equal url, @response.headers["Location"]
     assert_equal expected_redirect_body(url), @response.body
@@ -4163,7 +4163,7 @@ class TestRedirectInterpolation < ActionDispatch::IntegrationTest
   end
 
 private
-  def verify_redirect(url, status=301)
+  def verify_redirect(url, status = 301)
     assert_equal status, @response.status
     assert_equal url, @response.headers["Location"]
     assert_equal expected_redirect_body(url), @response.body
@@ -4189,7 +4189,7 @@ class TestConstraintsAccessingParameters < ActionDispatch::IntegrationTest
 
   test "parameters are reset between constraint checks" do
     get "/bar"
-    assert_equal nil, @request.params[:foo]
+    assert_nil @request.params[:foo]
     assert_equal "bar", @request.params[:bar]
   end
 end
@@ -4696,15 +4696,15 @@ class TestUrlGenerationErrors < ActionDispatch::IntegrationTest
   end
 
   test "url helpers raise message with mixed parameters when generation fails" do
-    url, missing = { action: "show", controller: "products", id: nil, "id"=>"url-tested" }, [:id]
+    url, missing = { action: "show", controller: "products", id: nil, "id" => "url-tested" }, [:id]
     message = "No route matches #{url.inspect}, possible unmatched constraints: #{missing.inspect}"
 
     # Optimized url helper
-    error = assert_raises(ActionController::UrlGenerationError) { product_path(nil, "id"=>"url-tested") }
+    error = assert_raises(ActionController::UrlGenerationError) { product_path(nil, "id" => "url-tested") }
     assert_equal message, error.message
 
     # Non-optimized url helper
-    error = assert_raises(ActionController::UrlGenerationError, message) { product_path(id: nil, "id"=>"url-tested") }
+    error = assert_raises(ActionController::UrlGenerationError, message) { product_path(id: nil, "id" => "url-tested") }
     assert_equal message, error.message
   end
 end
diff --git a/actionpack/test/dispatch/session/cache_store_test.rb b/actionpack/test/dispatch/session/cache_store_test.rb
index a60629a7ee..859059063f 100644
--- a/actionpack/test/dispatch/session/cache_store_test.rb
+++ b/actionpack/test/dispatch/session/cache_store_test.rb
@@ -142,20 +142,20 @@ class CacheStoreTest < ActionDispatch::IntegrationTest
 
       get "/get_session_value"
       assert_response :success
-      assert_equal nil, headers["Set-Cookie"], "should not resend the cookie again if session_id cookie is already exists"
+      assert_nil headers["Set-Cookie"], "should not resend the cookie again if session_id cookie is already exists"
     end
   end
 
   def test_prevents_session_fixation
     with_test_route_set do
-      assert_equal nil, @cache.read("_session_id:0xhax")
+      assert_nil @cache.read("_session_id:0xhax")
 
       cookies["_session_id"] = "0xhax"
       get "/set_session_value"
 
       assert_response :success
       assert_not_equal "0xhax", cookies["_session_id"]
-      assert_equal nil, @cache.read("_session_id:0xhax")
+      assert_nil @cache.read("_session_id:0xhax")
       assert_equal({ "foo" => "bar" }, @cache.read("_session_id:#{cookies['_session_id']}"))
     end
   end
diff --git a/actionpack/test/dispatch/session/cookie_store_test.rb b/actionpack/test/dispatch/session/cookie_store_test.rb
index 013d289c6d..2a1053be16 100644
--- a/actionpack/test/dispatch/session/cookie_store_test.rb
+++ b/actionpack/test/dispatch/session/cookie_store_test.rb
@@ -108,7 +108,7 @@ class CookieStoreTest < ActionDispatch::IntegrationTest
     with_test_route_set(secure: true) do
       get "/set_session_value"
       assert_response :success
-      assert_equal nil, headers["Set-Cookie"]
+      assert_nil headers["Set-Cookie"]
     end
   end
 
@@ -169,7 +169,7 @@ class CookieStoreTest < ActionDispatch::IntegrationTest
     with_test_route_set do
       get "/no_session_access"
       assert_response :success
-      assert_equal nil, headers["Set-Cookie"]
+      assert_nil headers["Set-Cookie"]
     end
   end
 
@@ -179,7 +179,7 @@ class CookieStoreTest < ActionDispatch::IntegrationTest
         "fef868465920f415f2c0652d6910d3af288a0367"
       get "/no_session_access"
       assert_response :success
-      assert_equal nil, headers["Set-Cookie"]
+      assert_nil headers["Set-Cookie"]
     end
   end
 
diff --git a/actionpack/test/dispatch/session/mem_cache_store_test.rb b/actionpack/test/dispatch/session/mem_cache_store_test.rb
index c2d0719b4e..121e9ebef7 100644
--- a/actionpack/test/dispatch/session/mem_cache_store_test.rb
+++ b/actionpack/test/dispatch/session/mem_cache_store_test.rb
@@ -157,7 +157,7 @@ class MemCacheStoreTest < ActionDispatch::IntegrationTest
 
         get "/get_session_value"
         assert_response :success
-        assert_equal nil, headers["Set-Cookie"], "should not resend the cookie again if session_id cookie is already exists"
+        assert_nil headers["Set-Cookie"], "should not resend the cookie again if session_id cookie is already exists"
       end
     rescue Dalli::RingError => ex
       skip ex.message, ex.backtrace
diff --git a/actionpack/test/dispatch/static_test.rb b/actionpack/test/dispatch/static_test.rb
index aca70e180c..d8bc96e3e0 100644
--- a/actionpack/test/dispatch/static_test.rb
+++ b/actionpack/test/dispatch/static_test.rb
@@ -143,16 +143,16 @@ module StaticTests
     assert_equal "Accept-Encoding",        response.headers["Vary"]
     assert_equal "gzip",                   response.headers["Content-Encoding"]
 
-    response  = get(file_name, "HTTP_ACCEPT_ENCODING" => "Gzip")
-    assert_gzip  file_name, response
+    response = get(file_name, "HTTP_ACCEPT_ENCODING" => "Gzip")
+    assert_gzip file_name, response
 
-    response  = get(file_name, "HTTP_ACCEPT_ENCODING" => "GZIP")
-    assert_gzip  file_name, response
+    response = get(file_name, "HTTP_ACCEPT_ENCODING" => "GZIP")
+    assert_gzip file_name, response
 
-    response  = get(file_name, "HTTP_ACCEPT_ENCODING" => "compress;q=0.5, gzip;q=1.0")
-    assert_gzip  file_name, response
+    response = get(file_name, "HTTP_ACCEPT_ENCODING" => "compress;q=0.5, gzip;q=1.0")
+    assert_gzip file_name, response
 
-    response  = get(file_name, "HTTP_ACCEPT_ENCODING" => "")
+    response = get(file_name, "HTTP_ACCEPT_ENCODING" => "")
     assert_not_equal "gzip", response.headers["Content-Encoding"]
   end
 
@@ -166,7 +166,7 @@ module StaticTests
   def test_serves_gzip_with_propper_content_type_fallback
     file_name = "/gzip/foo.zoo"
     response  = get(file_name, "HTTP_ACCEPT_ENCODING" => "gzip")
-    assert_gzip  file_name, response
+    assert_gzip file_name, response
 
     default_response = get(file_name) # no gzip
     assert_equal default_response.headers["Content-Type"], response.headers["Content-Type"]
@@ -177,9 +177,9 @@ module StaticTests
     last_modified = File.mtime(File.join(@root, "#{file_name}.gz"))
     response = get(file_name, "HTTP_ACCEPT_ENCODING" => "gzip", "HTTP_IF_MODIFIED_SINCE" => last_modified.httpdate)
     assert_equal 304, response.status
-    assert_equal nil, response.headers["Content-Type"]
-    assert_equal nil, response.headers["Content-Encoding"]
-    assert_equal nil, response.headers["Vary"]
+    assert_nil response.headers["Content-Type"]
+    assert_nil response.headers["Content-Encoding"]
+    assert_nil response.headers["Vary"]
   end
 
   def test_serves_files_with_headers
@@ -204,7 +204,7 @@ module StaticTests
   end
 
   # Windows doesn't allow \ / : * ? " < > | in filenames
-  unless RbConfig::CONFIG["host_os"] =~ /mswin|mingw/
+  unless Gem.win_platform?
     def test_serves_static_file_with_colon
       with_static_file "/foo/foo:bar.html" do |file|
         assert_html file, get("/foo/foo%3Abar.html")
@@ -269,14 +269,14 @@ class StaticTest < ActiveSupport::TestCase
     filename = "shared.html.erb"
     assert File.exist?(File.join(@root, "..", filename))
     env = {
-      "REQUEST_METHOD"=>"GET",
-      "REQUEST_PATH"=>"/..%2F#{filename}",
-      "PATH_INFO"=>"/..%2F#{filename}",
-      "REQUEST_URI"=>"/..%2F#{filename}",
-      "HTTP_VERSION"=>"HTTP/1.1",
-      "SERVER_NAME"=>"localhost",
-      "SERVER_PORT"=>"8080",
-      "QUERY_STRING"=>""
+      "REQUEST_METHOD" => "GET",
+      "REQUEST_PATH" => "/..%2F#{filename}",
+      "PATH_INFO" => "/..%2F#{filename}",
+      "REQUEST_URI" => "/..%2F#{filename}",
+      "HTTP_VERSION" => "HTTP/1.1",
+      "SERVER_NAME" => "localhost",
+      "SERVER_PORT" => "8080",
+      "QUERY_STRING" => ""
     }
     assert_equal(DummyApp.call(nil), @app.call(env))
   end
diff --git a/actionpack/test/dispatch/test_request_test.rb b/actionpack/test/dispatch/test_request_test.rb
index b479af781d..85a6df4975 100644
--- a/actionpack/test/dispatch/test_request_test.rb
+++ b/actionpack/test/dispatch/test_request_test.rb
@@ -30,7 +30,7 @@ class TestRequestTest < ActiveSupport::TestCase
     req = ActionDispatch::TestRequest.create({})
 
     assert_equal({}, req.cookies)
-    assert_equal nil, req.env["HTTP_COOKIE"]
+    assert_nil req.env["HTTP_COOKIE"]
 
     req.cookie_jar["user_name"] = "david"
     assert_cookies({ "user_name" => "david" }, req.cookie_jar)
diff --git a/actionpack/test/dispatch/uploaded_file_test.rb b/actionpack/test/dispatch/uploaded_file_test.rb
index 60d0246a68..51680216e4 100644
--- a/actionpack/test/dispatch/uploaded_file_test.rb
+++ b/actionpack/test/dispatch/uploaded_file_test.rb
@@ -58,25 +58,25 @@ module ActionDispatch
     end
 
     def test_delegates_close_to_tempfile
-      tf = Class.new { def close(unlink_now=false); "thunderhorse" end }
+      tf = Class.new { def close(unlink_now = false); "thunderhorse" end }
       uf = Http::UploadedFile.new(tempfile: tf.new)
       assert_equal "thunderhorse", uf.close
     end
 
     def test_close_accepts_parameter
-      tf = Class.new { def close(unlink_now=false); "thunderhorse: #{unlink_now}" end }
+      tf = Class.new { def close(unlink_now = false); "thunderhorse: #{unlink_now}" end }
       uf = Http::UploadedFile.new(tempfile: tf.new)
       assert_equal "thunderhorse: true", uf.close(true)
     end
 
     def test_delegates_read_to_tempfile
-      tf = Class.new { def read(length=nil, buffer=nil); "thunderhorse" end }
+      tf = Class.new { def read(length = nil, buffer = nil); "thunderhorse" end }
       uf = Http::UploadedFile.new(tempfile: tf.new)
       assert_equal "thunderhorse", uf.read
     end
 
     def test_delegates_read_to_tempfile_with_params
-      tf = Class.new { def read(length=nil, buffer=nil); [length, buffer] end }
+      tf = Class.new { def read(length = nil, buffer = nil); [length, buffer] end }
       uf = Http::UploadedFile.new(tempfile: tf.new)
       assert_equal %w{ thunder horse }, uf.read(*%w{ thunder horse })
     end
diff --git a/actionpack/test/fixtures/multipart/mona_lisa.jpg b/actionpack/test/fixtures/multipart/mona_lisa.jpg
deleted file mode 100644
index 5cf3bef3d0..0000000000
--- a/actionpack/test/fixtures/multipart/mona_lisa.jpg
+++ /dev/null
diff --git a/actionpack/test/fixtures/multipart/ruby_on_rails.jpg b/actionpack/test/fixtures/multipart/ruby_on_rails.jpg
new file mode 100644
index 0000000000..ed284ea0ba
--- /dev/null
+++ b/actionpack/test/fixtures/multipart/ruby_on_rails.jpg
diff --git a/actionpack/test/fixtures/session_autoload_test/session_autoload_test/foo.rb b/actionpack/test/fixtures/session_autoload_test/session_autoload_test/foo.rb
index cd0be6d1b5..18fa5cd923 100644
--- a/actionpack/test/fixtures/session_autoload_test/session_autoload_test/foo.rb
+++ b/actionpack/test/fixtures/session_autoload_test/session_autoload_test/foo.rb
@@ -1,6 +1,6 @@
 module SessionAutoloadTest
   class Foo
-    def initialize(bar="baz")
+    def initialize(bar = "baz")
       @bar = bar
     end
     def inspect
diff --git a/actionpack/test/journey/gtg/builder_test.rb b/actionpack/test/journey/gtg/builder_test.rb
index 2b314cdd4e..aa8427b265 100644
--- a/actionpack/test/journey/gtg/builder_test.rb
+++ b/actionpack/test/journey/gtg/builder_test.rb
@@ -5,18 +5,18 @@ module ActionDispatch
     module GTG
       class TestBuilder < ActiveSupport::TestCase
         def test_following_states_multi
-          table  = tt ["a|a"]
+          table = tt ["a|a"]
           assert_equal 1, table.move([0], "a").length
         end
 
         def test_following_states_multi_regexp
-          table  = tt [":a|b"]
+          table = tt [":a|b"]
           assert_equal 1, table.move([0], "fooo").length
           assert_equal 2, table.move([0], "b").length
         end
 
         def test_multi_path
-          table  = tt ["/:a/d", "/b/c"]
+          table = tt ["/:a/d", "/b/c"]
 
           [
             [1, "/"],
@@ -38,7 +38,7 @@ module ActionDispatch
             /articles/:id(.:format)
           }
 
-          sim     = NFA::Simulator.new table
+          sim = NFA::Simulator.new table
 
           match = sim.match "/articles/new"
           assert_equal 2, match.memos.length
@@ -52,7 +52,7 @@ module ActionDispatch
             /articles/new(.:format)
           }
 
-          sim     = NFA::Simulator.new table
+          sim = NFA::Simulator.new table
 
           match = sim.match "/articles/new"
           assert_equal 2, match.memos.length
diff --git a/actionpack/test/journey/gtg/transition_table_test.rb b/actionpack/test/journey/gtg/transition_table_test.rb
index 4c8b5032eb..c7315c0338 100644
--- a/actionpack/test/journey/gtg/transition_table_test.rb
+++ b/actionpack/test/journey/gtg/transition_table_test.rb
@@ -92,7 +92,7 @@ module ActionDispatch
 
         private
           def asts(paths)
-            parser  = Journey::Parser.new
+            parser = Journey::Parser.new
             paths.map { |x|
               ast = parser.parse x
               ast.each { |n| n.memo = ast }
diff --git a/actionpack/test/journey/nfa/simulator_test.rb b/actionpack/test/journey/nfa/simulator_test.rb
index 183c892a53..38f99398cb 100644
--- a/actionpack/test/journey/nfa/simulator_test.rb
+++ b/actionpack/test/journey/nfa/simulator_test.rb
@@ -80,7 +80,7 @@ module ActionDispatch
 
           ast = Nodes::Or.new routes
 
-          nfa   = Journey::NFA::Builder.new ast
+          nfa = Journey::NFA::Builder.new ast
           sim = Simulator.new nfa.transition_table
           md = sim.match "/articles"
           assert_equal [asts.first], md.memos
diff --git a/actionpack/test/journey/nfa/transition_table_test.rb b/actionpack/test/journey/nfa/transition_table_test.rb
index f3cf36a064..0bc6bc1cf8 100644
--- a/actionpack/test/journey/nfa/transition_table_test.rb
+++ b/actionpack/test/journey/nfa/transition_table_test.rb
@@ -53,10 +53,10 @@ module ActionDispatch
         end
 
         def test_alphabet
-          table  = tt "a|:a"
+          table = tt "a|:a"
           assert_equal [/[^\.\/\?]+/, "a"], table.alphabet
 
-          table  = tt "a|a"
+          table = tt "a|a"
           assert_equal ["a"], table.alphabet
         end
 
diff --git a/actionpack/test/journey/route_test.rb b/actionpack/test/journey/route_test.rb
index b6414fd101..8fd73970b8 100644
--- a/actionpack/test/journey/route_test.rb
+++ b/actionpack/test/journey/route_test.rb
@@ -26,7 +26,7 @@ module ActionDispatch
       end
 
       def test_path_requirements_override_defaults
-        path    = Path::Pattern.build(":name", { name: /love/ }, "/", true)
+        path = Path::Pattern.build(":name", { name: /love/ }, "/", true)
         defaults  = { name: "tender" }
         route     = Route.build("name", nil, path, {}, [], defaults)
         assert_equal(/love/, route.requirements[:name])
@@ -96,7 +96,7 @@ module ActionDispatch
         path = Path::Pattern.from_string "/:controller(/:action(/:id))(.:format)"
         generic = Route.build "name", nil, path, constraints, [], {}
 
-        knowledge = { id: 20, controller: "pages", action: "show" }
+        knowledge = { "id" => true, "controller" => true, "action" => true }
 
         routes = [specific, generic]
 
diff --git a/actionpack/test/journey/router_test.rb b/actionpack/test/journey/router_test.rb
index 7b5916eb72..f223a125a3 100644
--- a/actionpack/test/journey/router_test.rb
+++ b/actionpack/test/journey/router_test.rb
@@ -6,8 +6,8 @@ module ActionDispatch
       attr_reader :mapper, :routes, :route_set, :router
 
       def setup
-        @app       = Routing::RouteSet::Dispatcher.new({})
-        @route_set  = ActionDispatch::Routing::RouteSet.new
+        @app = Routing::RouteSet::Dispatcher.new({})
+        @route_set = ActionDispatch::Routing::RouteSet.new
         @routes = @route_set.router.routes
         @router = @route_set.router
         @formatter = @route_set.formatter
@@ -116,7 +116,7 @@ module ActionDispatch
       end
 
       def test_clear_trailing_slash_from_script_name_on_root_unanchored_routes
-        app    = lambda { |env| [200, {}, ["success!"]] }
+        app = lambda { |env| [200, {}, ["success!"]] }
         get "/weblog", to: app
 
         env  = rack_env("SCRIPT_NAME" => "", "PATH_INFO" => "/weblog")
@@ -233,7 +233,7 @@ module ActionDispatch
           nil,
           Hash[params],
           {},
-          lambda { |k,v| parameterized << [k,v]; v })
+          lambda { |k, v| parameterized << [k, v]; v })
 
         assert_equal params.map(&:to_s).sort, parameterized.map(&:to_s).sort
       end
@@ -289,15 +289,15 @@ module ActionDispatch
           relative_url_root: nil
         }
         redirection_parameters = {
-          "action"=>"show",
+          "action" => "show",
         }
         missing_key = "name"
-        missing_parameters ={
+        missing_parameters = {
           missing_key => "task_1"
         }
         request_parameters = primarty_parameters.merge(redirection_parameters).merge(missing_parameters)
 
-        message = "No route matches #{Hash[request_parameters.sort_by { |k,v|k.to_s }].inspect}, missing required keys: #{[missing_key.to_sym].inspect}"
+        message = "No route matches #{Hash[request_parameters.sort_by { |k, v|k.to_s }].inspect}, missing required keys: #{[missing_key.to_sym].inspect}"
 
         error = assert_raises(ActionController::UrlGenerationError) do
           @formatter.generate(
@@ -338,7 +338,7 @@ module ActionDispatch
           route = @routes.first
 
           env = rails_env "PATH_INFO" => request_path
-          called   = false
+          called = false
 
           router.recognize(env) do |r, params|
             assert_equal route, r
@@ -358,7 +358,7 @@ module ActionDispatch
           get "/:segment/*splat", to: "foo#bar"
 
           env = rails_env "PATH_INFO" => request_path
-          called   = false
+          called = false
           route = @routes.first
 
           router.recognize(env) do |r, params|
@@ -395,7 +395,7 @@ module ActionDispatch
         get "/books(/:action(.:format))", controller: "books"
         route = @routes.first
 
-        env    = rails_env "PATH_INFO" => "/books/list.rss"
+        env = rails_env "PATH_INFO" => "/books/list.rss"
         expected = { controller: "books", action: "list", format: "rss" }
         called = false
         router.recognize(env) do |r, params|
@@ -427,7 +427,7 @@ module ActionDispatch
         get "/books(/:action(.:format))", to: "foo#bar"
 
         env = rails_env "PATH_INFO" => "/books/list.rss",
-                        "REQUEST_METHOD"    => "HEAD"
+                        "REQUEST_METHOD" => "HEAD"
 
         called = false
         router.recognize(env) do |r, params|
diff --git a/actionpack/test/journey/routes_test.rb b/actionpack/test/journey/routes_test.rb
index ca735ea022..d8db5ffad1 100644
--- a/actionpack/test/journey/routes_test.rb
+++ b/actionpack/test/journey/routes_test.rb
@@ -6,7 +6,7 @@ module ActionDispatch
       attr_reader :routes, :mapper
 
       def setup
-        @route_set  = ActionDispatch::Routing::RouteSet.new
+        @route_set = ActionDispatch::Routing::RouteSet.new
         @routes = @route_set.router.routes
         @router = @route_set.router
         @mapper = ActionDispatch::Routing::Mapper.new @route_set
diff --git a/actionpack/test/lib/controller/fake_models.rb b/actionpack/test/lib/controller/fake_models.rb
index ce9522d12a..046b4167bb 100644
--- a/actionpack/test/lib/controller/fake_models.rb
+++ b/actionpack/test/lib/controller/fake_models.rb
@@ -6,7 +6,7 @@ class Customer < Struct.new(:name, :id)
 
   undef_method :to_json
 
-  def to_xml(options={})
+  def to_xml(options = {})
     if options[:builder]
       options[:builder].name name
     else
@@ -14,7 +14,7 @@ class Customer < Struct.new(:name, :id)
     end
   end
 
-  def to_js(options={})
+  def to_js(options = {})
     "name: #{name.inspect}"
   end
   alias :to_text :to_js