9 files changed, 101 insertions, 156 deletions

diff --git a/actionpack/test/dispatch/callbacks_test.rb b/actionpack/test/dispatch/callbacks_test.rb
index 57e21a22c6..29a5dfc0ad 100644
--- a/actionpack/test/dispatch/callbacks_test.rb
+++ b/actionpack/test/dispatch/callbacks_test.rb
@@ -35,24 +35,6 @@ class DispatcherTest < ActiveSupport::TestCase
     assert_equal 6, Foo.b
   end
 
-  def test_to_prepare_and_cleanup_delegation
-    prepared = cleaned = false
-    assert_deprecated do
-      ActionDispatch::Callbacks.to_prepare { prepared = true }
-      ActionDispatch::Callbacks.to_prepare { cleaned = true }
-    end
-
-    assert_deprecated do
-      ActionDispatch::Reloader.prepare!
-    end
-    assert prepared
-
-    assert_deprecated do
-      ActionDispatch::Reloader.cleanup!
-    end
-    assert cleaned
-  end
-
   private
 
     def dispatch(&block)
diff --git a/actionpack/test/dispatch/prefix_generation_test.rb b/actionpack/test/dispatch/prefix_generation_test.rb
index bb2fc53add..0e093d2188 100644
--- a/actionpack/test/dispatch/prefix_generation_test.rb
+++ b/actionpack/test/dispatch/prefix_generation_test.rb
@@ -22,8 +22,6 @@ module TestGenerationPrefix
   end
 
   class WithMountedEngine < ActionDispatch::IntegrationTest
-    include Rack::Test::Methods
-
     class BlogEngine < Rails::Engine
       routes.draw do
         get "/posts/:id", to: "inside_engine_generating#show", as: :post
@@ -153,114 +151,114 @@ module TestGenerationPrefix
     # Inside Engine
     test "[ENGINE] generating engine's url use SCRIPT_NAME from request" do
       get "/pure-awesomeness/blog/posts/1"
-      assert_equal "/pure-awesomeness/blog/posts/1", last_response.body
+      assert_equal "/pure-awesomeness/blog/posts/1", response.body
     end
 
     test "[ENGINE] generating application's url never uses SCRIPT_NAME from request" do
       get "/pure-awesomeness/blog/url_to_application"
-      assert_equal "/generate", last_response.body
+      assert_equal "/generate", response.body
     end
 
     test "[ENGINE] generating engine's url with polymorphic path" do
       get "/pure-awesomeness/blog/polymorphic_path_for_engine"
-      assert_equal "/pure-awesomeness/blog/posts/1", last_response.body
+      assert_equal "/pure-awesomeness/blog/posts/1", response.body
     end
 
     test "[ENGINE] url_helpers from engine have higher priority than application's url_helpers" do
       get "/awesome/blog/conflicting_url"
-      assert_equal "engine", last_response.body
+      assert_equal "engine", response.body
     end
 
     test "[ENGINE] relative path root uses SCRIPT_NAME from request" do
       get "/awesome/blog/relative_path_root"
-      verify_redirect "http://example.org/awesome/blog"
+      verify_redirect "http://www.example.com/awesome/blog"
     end
 
     test "[ENGINE] relative path redirect uses SCRIPT_NAME from request" do
       get "/awesome/blog/relative_path_redirect"
-      verify_redirect "http://example.org/awesome/blog/foo"
+      verify_redirect "http://www.example.com/awesome/blog/foo"
     end
 
     test "[ENGINE] relative option root uses SCRIPT_NAME from request" do
       get "/awesome/blog/relative_option_root"
-      verify_redirect "http://example.org/awesome/blog"
+      verify_redirect "http://www.example.com/awesome/blog"
     end
 
     test "[ENGINE] relative option redirect uses SCRIPT_NAME from request" do
       get "/awesome/blog/relative_option_redirect"
-      verify_redirect "http://example.org/awesome/blog/foo"
+      verify_redirect "http://www.example.com/awesome/blog/foo"
     end
 
     test "[ENGINE] relative custom root uses SCRIPT_NAME from request" do
       get "/awesome/blog/relative_custom_root"
-      verify_redirect "http://example.org/awesome/blog"
+      verify_redirect "http://www.example.com/awesome/blog"
     end
 
     test "[ENGINE] relative custom redirect uses SCRIPT_NAME from request" do
       get "/awesome/blog/relative_custom_redirect"
-      verify_redirect "http://example.org/awesome/blog/foo"
+      verify_redirect "http://www.example.com/awesome/blog/foo"
     end
 
     test "[ENGINE] absolute path root doesn't use SCRIPT_NAME from request" do
       get "/awesome/blog/absolute_path_root"
-      verify_redirect "http://example.org/"
+      verify_redirect "http://www.example.com/"
     end
 
     test "[ENGINE] absolute path redirect doesn't use SCRIPT_NAME from request" do
       get "/awesome/blog/absolute_path_redirect"
-      verify_redirect "http://example.org/foo"
+      verify_redirect "http://www.example.com/foo"
     end
 
     test "[ENGINE] absolute option root doesn't use SCRIPT_NAME from request" do
       get "/awesome/blog/absolute_option_root"
-      verify_redirect "http://example.org/"
+      verify_redirect "http://www.example.com/"
     end
 
     test "[ENGINE] absolute option redirect doesn't use SCRIPT_NAME from request" do
       get "/awesome/blog/absolute_option_redirect"
-      verify_redirect "http://example.org/foo"
+      verify_redirect "http://www.example.com/foo"
     end
 
     test "[ENGINE] absolute custom root doesn't use SCRIPT_NAME from request" do
       get "/awesome/blog/absolute_custom_root"
-      verify_redirect "http://example.org/"
+      verify_redirect "http://www.example.com/"
     end
 
     test "[ENGINE] absolute custom redirect doesn't use SCRIPT_NAME from request" do
       get "/awesome/blog/absolute_custom_redirect"
-      verify_redirect "http://example.org/foo"
+      verify_redirect "http://www.example.com/foo"
     end
 
     # Inside Application
     test "[APP] generating engine's route includes prefix" do
       get "/generate"
-      assert_equal "/awesome/blog/posts/1", last_response.body
+      assert_equal "/awesome/blog/posts/1", response.body
     end
 
     test "[APP] generating engine's route includes default_url_options[:script_name]" do
       RailsApplication.routes.default_url_options = { script_name: "/something" }
       get "/generate"
-      assert_equal "/something/awesome/blog/posts/1", last_response.body
+      assert_equal "/something/awesome/blog/posts/1", response.body
     end
 
     test "[APP] generating engine's url with polymorphic path" do
       get "/polymorphic_path_for_engine"
-      assert_equal "/awesome/blog/posts/1", last_response.body
+      assert_equal "/awesome/blog/posts/1", response.body
     end
 
     test "polymorphic_path_for_app" do
       get "/polymorphic_path_for_app"
-      assert_equal "/posts/1", last_response.body
+      assert_equal "/posts/1", response.body
     end
 
     test "[APP] generating engine's url with url_for(@post)" do
       get "/polymorphic_with_url_for"
-      assert_equal "http://example.org/awesome/blog/posts/1", last_response.body
+      assert_equal "http://www.example.com/awesome/blog/posts/1", response.body
     end
 
     test "[APP] instance variable with same name as engine" do
       get "/ivar_usage"
-      assert_equal "/awesome/blog/posts/1", last_response.body
+      assert_equal "/awesome/blog/posts/1", response.body
     end
 
     # Inside any Object
@@ -322,9 +320,9 @@ module TestGenerationPrefix
 
     private
       def verify_redirect(url, status = 301)
-        assert_equal status, last_response.status
-        assert_equal url, last_response.headers["Location"]
-        assert_equal expected_redirect_body(url), last_response.body
+        assert_equal status, response.status
+        assert_equal url, response.headers["Location"]
+        assert_equal expected_redirect_body(url), response.body
       end
 
       def expected_redirect_body(url)
@@ -333,8 +331,6 @@ module TestGenerationPrefix
   end
 
   class EngineMountedAtRoot < ActionDispatch::IntegrationTest
-    include Rack::Test::Methods
-
     class BlogEngine
       def self.routes
         @routes ||= begin
@@ -388,74 +384,74 @@ module TestGenerationPrefix
 
     test "generating path inside engine" do
       get "/posts/1"
-      assert_equal "/posts/1", last_response.body
+      assert_equal "/posts/1", response.body
     end
 
     test "[ENGINE] relative path root uses SCRIPT_NAME from request" do
       get "/relative_path_root"
-      verify_redirect "http://example.org/"
+      verify_redirect "http://www.example.com/"
     end
 
     test "[ENGINE] relative path redirect uses SCRIPT_NAME from request" do
       get "/relative_path_redirect"
-      verify_redirect "http://example.org/foo"
+      verify_redirect "http://www.example.com/foo"
     end
 
     test "[ENGINE] relative option root uses SCRIPT_NAME from request" do
       get "/relative_option_root"
-      verify_redirect "http://example.org/"
+      verify_redirect "http://www.example.com/"
     end
 
     test "[ENGINE] relative option redirect uses SCRIPT_NAME from request" do
       get "/relative_option_redirect"
-      verify_redirect "http://example.org/foo"
+      verify_redirect "http://www.example.com/foo"
     end
 
     test "[ENGINE] relative custom root uses SCRIPT_NAME from request" do
       get "/relative_custom_root"
-      verify_redirect "http://example.org/"
+      verify_redirect "http://www.example.com/"
     end
 
     test "[ENGINE] relative custom redirect uses SCRIPT_NAME from request" do
       get "/relative_custom_redirect"
-      verify_redirect "http://example.org/foo"
+      verify_redirect "http://www.example.com/foo"
     end
 
     test "[ENGINE] absolute path root doesn't use SCRIPT_NAME from request" do
       get "/absolute_path_root"
-      verify_redirect "http://example.org/"
+      verify_redirect "http://www.example.com/"
     end
 
     test "[ENGINE] absolute path redirect doesn't use SCRIPT_NAME from request" do
       get "/absolute_path_redirect"
-      verify_redirect "http://example.org/foo"
+      verify_redirect "http://www.example.com/foo"
     end
 
     test "[ENGINE] absolute option root doesn't use SCRIPT_NAME from request" do
       get "/absolute_option_root"
-      verify_redirect "http://example.org/"
+      verify_redirect "http://www.example.com/"
     end
 
     test "[ENGINE] absolute option redirect doesn't use SCRIPT_NAME from request" do
       get "/absolute_option_redirect"
-      verify_redirect "http://example.org/foo"
+      verify_redirect "http://www.example.com/foo"
     end
 
     test "[ENGINE] absolute custom root doesn't use SCRIPT_NAME from request" do
       get "/absolute_custom_root"
-      verify_redirect "http://example.org/"
+      verify_redirect "http://www.example.com/"
     end
 
     test "[ENGINE] absolute custom redirect doesn't use SCRIPT_NAME from request" do
       get "/absolute_custom_redirect"
-      verify_redirect "http://example.org/foo"
+      verify_redirect "http://www.example.com/foo"
     end
 
     private
       def verify_redirect(url, status = 301)
-        assert_equal status, last_response.status
-        assert_equal url, last_response.headers["Location"]
-        assert_equal expected_redirect_body(url), last_response.body
+        assert_equal status, response.status
+        assert_equal url, response.headers["Location"]
+        assert_equal expected_redirect_body(url), response.body
       end
 
       def expected_redirect_body(url)
diff --git a/actionpack/test/dispatch/reloader_test.rb b/actionpack/test/dispatch/reloader_test.rb
index db68549b84..797430c85a 100644
--- a/actionpack/test/dispatch/reloader_test.rb
+++ b/actionpack/test/dispatch/reloader_test.rb
@@ -1,32 +1,11 @@
 require "abstract_unit"
 
 class ReloaderTest < ActiveSupport::TestCase
-  Reloader = ActionDispatch::Reloader
-
   teardown do
     ActiveSupport::Reloader.reset_callbacks :prepare
     ActiveSupport::Reloader.reset_callbacks :complete
   end
 
-  def test_prepare_callbacks
-    a = b = c = nil
-    assert_deprecated do
-      Reloader.to_prepare { |*args| a = b = c = 1 }
-      Reloader.to_prepare { |*args| b = c = 2 }
-      Reloader.to_prepare { |*args| c = 3 }
-    end
-
-    # Ensure to_prepare callbacks are not run when defined
-    assert_nil a || b || c
-
-    # Run callbacks
-    call_and_return_body
-
-    assert_equal 1, a
-    assert_equal 2, b
-    assert_equal 3, c
-  end
-
   class MyBody < Array
     def initialize(&block)
       @on_close = block
@@ -45,6 +24,23 @@ class ReloaderTest < ActiveSupport::TestCase
     end
   end
 
+  def test_prepare_callbacks
+    a = b = c = nil
+    reloader.to_prepare { |*args| a = b = c = 1 }
+    reloader.to_prepare { |*args| b = c = 2 }
+    reloader.to_prepare { |*args| c = 3 }
+
+    # Ensure to_prepare callbacks are not run when defined
+    assert_nil a || b || c
+
+    # Run callbacks
+    call_and_return_body
+
+    assert_equal 1, a
+    assert_equal 2, b
+    assert_equal 3, c
+  end
+
   def test_returned_body_object_always_responds_to_close
     body = call_and_return_body
     assert_respond_to body, :close
@@ -62,15 +58,12 @@ class ReloaderTest < ActiveSupport::TestCase
 
   def test_condition_specifies_when_to_reload
     i, j = 0, 0, 0, 0
-    assert_deprecated do
-      Reloader.to_prepare { |*args| i += 1 }
-      Reloader.to_cleanup { |*args| j += 1 }
-    end
 
-    x = Class.new(ActiveSupport::Reloader)
-    x.check = lambda { i < 3 }
+    reloader = reloader(lambda { i < 3 })
+    reloader.to_prepare { |*args| i += 1 }
+    reloader.to_complete { |*args| j += 1 }
 
-    app = Reloader.new(lambda { |env| [200, {}, []] }, x)
+    app = middleware(lambda { |env| [200, {}, []] }, reloader)
     5.times do
       resp = app.call({})
       resp[2].close
@@ -115,24 +108,20 @@ class ReloaderTest < ActiveSupport::TestCase
     assert_respond_to body, :bar
   end
 
-  def test_cleanup_callbacks_are_called_when_body_is_closed
-    cleaned = false
-    assert_deprecated do
-      Reloader.to_cleanup { cleaned = true }
-    end
+  def test_complete_callbacks_are_called_when_body_is_closed
+    completed = false
+    reloader.to_complete { completed = true }
 
     body = call_and_return_body
-    assert !cleaned
+    assert !completed
 
     body.close
-    assert cleaned
+    assert completed
   end
 
   def test_prepare_callbacks_arent_called_when_body_is_closed
     prepared = false
-    assert_deprecated do
-      Reloader.to_prepare { prepared = true }
-    end
+    reloader.to_prepare { prepared = true }
 
     body = call_and_return_body
     prepared = false
@@ -141,45 +130,9 @@ class ReloaderTest < ActiveSupport::TestCase
     assert !prepared
   end
 
-  def test_manual_reloading
-    prepared = cleaned = false
-    assert_deprecated do
-      Reloader.to_prepare { prepared = true }
-      Reloader.to_cleanup { cleaned  = true }
-    end
-
-    assert_deprecated do
-      Reloader.prepare!
-    end
-    assert prepared
-    assert !cleaned
-
-    prepared = cleaned = false
-    assert_deprecated do
-      Reloader.cleanup!
-    end
-    assert prepared
-    assert cleaned
-  end
-
-  def test_prepend_prepare_callback
-    i = 10
-    assert_deprecated do
-      Reloader.to_prepare { i += 1 }
-      Reloader.to_prepare(prepend: true) { i = 0 }
-    end
-
-    assert_deprecated do
-      Reloader.prepare!
-    end
-    assert_equal 1, i
-  end
-
-  def test_cleanup_callbacks_are_called_on_exceptions
-    cleaned = false
-    assert_deprecated do
-      Reloader.to_cleanup { cleaned = true }
-    end
+  def test_complete_callbacks_are_called_on_exceptions
+    completed = false
+    reloader.to_complete { completed = true }
 
     begin
       call_and_return_body do
@@ -188,16 +141,26 @@ class ReloaderTest < ActiveSupport::TestCase
     rescue
     end
 
-    assert cleaned
+    assert completed
   end
 
   private
     def call_and_return_body(&block)
-      x = Class.new(ActiveSupport::Reloader)
-      x.check = lambda { true }
+      app = middleware(block || proc { [200, {}, "response"] })
+      _, _, body = app.call("rack.input" => StringIO.new(""))
+      body
+    end
+
+    def middleware(inner_app, reloader = reloader())
+      ActionDispatch::Reloader.new(inner_app, reloader)
+    end
+
+    def reloader(check = lambda { true })
+      @reloader ||= begin
+                      reloader = Class.new(ActiveSupport::Reloader)
+                      reloader.check = check
+                      reloader
+                    end
 
-      @response ||= "response"
-      @reloader ||= Reloader.new(block || proc { [200, {}, @response] }, x)
-      @reloader.call("rack.input" => StringIO.new(""))[2]
     end
 end
diff --git a/actionpack/test/dispatch/request_test.rb b/actionpack/test/dispatch/request_test.rb
index e11b93b4f0..2f9228a62d 100644
--- a/actionpack/test/dispatch/request_test.rb
+++ b/actionpack/test/dispatch/request_test.rb
@@ -760,8 +760,8 @@ class RequestMethod < BaseRequestTest
   end
 
   test "post uneffected by local inflections" do
-    existing_acrnoyms = ActiveSupport::Inflector.inflections.acronyms.dup
-    existing_acrnoym_regex = ActiveSupport::Inflector.inflections.acronym_regex.dup
+    existing_acronyms = ActiveSupport::Inflector.inflections.acronyms.dup
+    existing_acronym_regex = ActiveSupport::Inflector.inflections.acronym_regex.dup
     begin
       ActiveSupport::Inflector.inflections do |inflect|
         inflect.acronym "POS"
@@ -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_acronyms)
+        inflect.send(:instance_variable_set, "@acronym_regex", existing_acronym_regex)
       end
     end
   end
diff --git a/actionpack/test/dispatch/response_test.rb b/actionpack/test/dispatch/response_test.rb
index 3cf7f4821d..7433c5ce0c 100644
--- a/actionpack/test/dispatch/response_test.rb
+++ b/actionpack/test/dispatch/response_test.rb
@@ -111,7 +111,7 @@ class ResponseTest < ActiveSupport::TestCase
   end
 
   def test_empty_content_type_returns_nil
-    @response.headers['Content-Type'] = ""
+    @response.headers["Content-Type"] = ""
     assert_nil @response.content_type
   end
 
diff --git a/actionpack/test/dispatch/routing_test.rb b/actionpack/test/dispatch/routing_test.rb
index 474d053af6..53758a4fbc 100644
--- a/actionpack/test/dispatch/routing_test.rb
+++ b/actionpack/test/dispatch/routing_test.rb
@@ -1603,7 +1603,7 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
       get "account/login", to: redirect("/login")
     end
 
-    previous_host, self.host = self.host, "www.example.com:3000"
+    previous_host, self.host = host, "www.example.com:3000"
 
     get "/account/login"
     verify_redirect "http://www.example.com:3000/login"
diff --git a/actionpack/test/dispatch/session/cookie_store_test.rb b/actionpack/test/dispatch/session/cookie_store_test.rb
index 2a1053be16..63dfc07c0d 100644
--- a/actionpack/test/dispatch/session/cookie_store_test.rb
+++ b/actionpack/test/dispatch/session/cookie_store_test.rb
@@ -175,7 +175,7 @@ class CookieStoreTest < ActionDispatch::IntegrationTest
 
   def test_doesnt_write_session_cookie_if_session_is_unchanged
     with_test_route_set do
-      cookies[SessionKey] = "BAh7BjoIZm9vIghiYXI%3D--" +
+      cookies[SessionKey] = "BAh7BjoIZm9vIghiYXI%3D--" \
         "fef868465920f415f2c0652d6910d3af288a0367"
       get "/no_session_access"
       assert_response :success
diff --git a/actionpack/test/dispatch/ssl_test.rb b/actionpack/test/dispatch/ssl_test.rb
index e29ffa750c..757e26973f 100644
--- a/actionpack/test/dispatch/ssl_test.rb
+++ b/actionpack/test/dispatch/ssl_test.rb
@@ -102,7 +102,11 @@ class StrictTransportSecurityTest < SSLTest
   def assert_hsts(expected, url: "https://example.org", hsts: { subdomains: true }, headers: {})
     self.app = build_app ssl_options: { hsts: hsts }, headers: headers
     get url
-    assert_equal expected, response.headers["Strict-Transport-Security"]
+    if expected.nil?
+      assert_nil response.headers["Strict-Transport-Security"]
+    else
+      assert_equal expected, response.headers["Strict-Transport-Security"]
+    end
   end
 
   test "enabled by default" do
@@ -130,7 +134,7 @@ class StrictTransportSecurityTest < SSLTest
   end
 
   test ":expires supports AS::Duration arguments" do
-    assert_hsts "max-age=31557600; includeSubDomains", hsts: { expires: 1.year }
+    assert_hsts "max-age=31556952; includeSubDomains", hsts: { expires: 1.year }
   end
 
   test "include subdomains" do
diff --git a/actionpack/test/dispatch/static_test.rb b/actionpack/test/dispatch/static_test.rb
index d8bc96e3e0..bd8318f5f6 100644
--- a/actionpack/test/dispatch/static_test.rb
+++ b/actionpack/test/dispatch/static_test.rb
@@ -163,7 +163,7 @@ module StaticTests
     assert_equal file_name, env["PATH_INFO"]
   end
 
-  def test_serves_gzip_with_propper_content_type_fallback
+  def test_serves_gzip_with_proper_content_type_fallback
     file_name = "/gzip/foo.zoo"
     response  = get(file_name, "HTTP_ACCEPT_ENCODING" => "gzip")
     assert_gzip file_name, response