Merge remote-tracking branch 'upstream/master'

11 files changed, 436 insertions, 108 deletions

diff --git a/actionpack/test/dispatch/cookies_test.rb b/actionpack/test/dispatch/cookies_test.rb
index fb67ecb07d..3765b7eb44 100644
--- a/actionpack/test/dispatch/cookies_test.rb
+++ b/actionpack/test/dispatch/cookies_test.rb
@@ -148,6 +148,22 @@ class CookiesTest < ActionController::TestCase
     @request.host = "www.nextangle.com"
   end
 
+  def test_each
+    request.cookie_jar['foo'] = :bar
+    list = []
+    request.cookie_jar.each do |k,v|
+      list << [k, v]
+    end
+
+    assert_equal [['foo', :bar]], list
+  end
+
+  def test_enumerable
+    request.cookie_jar['foo'] = :bar
+    actual = request.cookie_jar.map { |k,v| [k.to_s, v.to_s] }
+    assert_equal [['foo', 'bar']], actual
+  end
+
   def test_key_methods
     assert !request.cookie_jar.key?(:foo)
     assert !request.cookie_jar.has_key?("foo")
@@ -194,8 +210,8 @@ class CookiesTest < ActionController::TestCase
     assert_equal({"user_name" => "david"}, @response.cookies)
   end
 
-  def test_setting_cookie_with_secure_in_development
-    Rails.env.stubs(:development?).returns(true)
+  def test_setting_cookie_with_secure_when_always_write_cookie_is_true
+    ActionDispatch::Cookies::CookieJar.any_instance.stubs(:always_write_cookie).returns(true)
     get :authenticate_with_secure
     assert_cookie_header "user_name=david; path=/; secure"
     assert_equal({"user_name" => "david"}, @response.cookies)
diff --git a/actionpack/test/dispatch/mapper_test.rb b/actionpack/test/dispatch/mapper_test.rb
index 3316dd03aa..d3465589c1 100644
--- a/actionpack/test/dispatch/mapper_test.rb
+++ b/actionpack/test/dispatch/mapper_test.rb
@@ -5,6 +5,7 @@ module ActionDispatch
     class MapperTest < ActiveSupport::TestCase
       class FakeSet
         attr_reader :routes
+        alias :set :routes
 
         def initialize
           @routes = []
diff --git a/actionpack/test/dispatch/mime_type_test.rb b/actionpack/test/dispatch/mime_type_test.rb
index 851fb59d51..08fe2127b9 100644
--- a/actionpack/test/dispatch/mime_type_test.rb
+++ b/actionpack/test/dispatch/mime_type_test.rb
@@ -107,8 +107,10 @@ class MimeTypeTest < ActiveSupport::TestCase
     # Remove custom Mime::Type instances set in other tests, like Mime::GIF and Mime::IPHONE
     types.delete_if { |type| !Mime.const_defined?(type.to_s.upcase) }
 
+
     types.each do |type|
       mime = Mime.const_get(type.to_s.upcase)
+      assert mime.respond_to?("#{type}?"), "#{mime.inspect} does not respond to #{type}?"
       assert mime.send("#{type}?"), "#{mime.inspect} is not #{type}?"
       invalid_types = types - [type]
       invalid_types.delete(:html) if Mime::Type.html_types.include?(type)
diff --git a/actionpack/test/dispatch/request/json_params_parsing_test.rb b/actionpack/test/dispatch/request/json_params_parsing_test.rb
index d854d55173..ad44b4b16a 100644
--- a/actionpack/test/dispatch/request/json_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/json_params_parsing_test.rb
@@ -32,13 +32,21 @@ class JsonParamsParsingTest < ActionDispatch::IntegrationTest
 
   test "logs error if parsing unsuccessful" do
     with_test_routing do
+      output = StringIO.new
+      json = "[\"person]\": {\"name\": \"David\"}}"
+      post "/parse", json, {'CONTENT_TYPE' => 'application/json', 'action_dispatch.show_exceptions' => true, 'action_dispatch.logger' => Logger.new(output)}
+      assert_response :error
+      output.rewind && err = output.read
+      assert err =~ /Error occurred while parsing request parameters/
+    end
+  end
+
+  test "occurring a parse error if parsing unsuccessful" do
+    with_test_routing do
       begin
-        $stderr = StringIO.new
+        $stderr = StringIO.new # suppress the log
         json = "[\"person]\": {\"name\": \"David\"}}"
-        post "/parse", json, {'CONTENT_TYPE' => 'application/json', 'action_dispatch.show_exceptions' => true}
-        assert_response :error
-        $stderr.rewind && err = $stderr.read
-        assert err =~ /Error occurred while parsing request parameters/
+        assert_raise(MultiJson::DecodeError) { post "/parse", json, {'CONTENT_TYPE' => 'application/json', 'action_dispatch.show_exceptions' => false} }
       ensure
         $stderr = STDERR
       end
diff --git a/actionpack/test/dispatch/request/xml_params_parsing_test.rb b/actionpack/test/dispatch/request/xml_params_parsing_test.rb
index 38453dfe48..d8fa751548 100644
--- a/actionpack/test/dispatch/request/xml_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/xml_params_parsing_test.rb
@@ -54,13 +54,21 @@ class XmlParamsParsingTest < ActionDispatch::IntegrationTest
 
   test "logs error if parsing unsuccessful" do
     with_test_routing do
+      output = StringIO.new
+      xml = "<person><name>David</name><avatar type='file' name='me.jpg' content_type='image/jpg'>#{ActiveSupport::Base64.encode64('ABC')}</avatar></pineapple>"
+      post "/parse", xml, default_headers.merge('action_dispatch.show_exceptions' => true, 'action_dispatch.logger' => Logger.new(output))
+      assert_response :error
+      output.rewind && err = output.read
+      assert err =~ /Error occurred while parsing request parameters/
+    end
+  end
+
+  test "occurring a parse error if parsing unsuccessful" do
+    with_test_routing do
       begin
-        $stderr = StringIO.new
-        xml = "<person><name>David</name><avatar type='file' name='me.jpg' content_type='image/jpg'>#{ActiveSupport::Base64.encode64('ABC')}</avatar></pineapple>"
-        post "/parse", xml, default_headers.merge('action_dispatch.show_exceptions' => true)
-        assert_response :error
-        $stderr.rewind && err = $stderr.read
-        assert err =~ /Error occurred while parsing request parameters/
+        $stderr = StringIO.new # suppress the log
+        xml = "<person><name>David</name></pineapple>"
+        assert_raise(REXML::ParseException) { post "/parse", xml, default_headers.merge('action_dispatch.show_exceptions' => false) }
       ensure
         $stderr = STDERR
       end
diff --git a/actionpack/test/dispatch/request_id_test.rb b/actionpack/test/dispatch/request_id_test.rb
new file mode 100644
index 0000000000..b6e8b6c3ad
--- /dev/null
+++ b/actionpack/test/dispatch/request_id_test.rb
@@ -0,0 +1,65 @@
+require 'abstract_unit'
+
+class RequestIdTest < ActiveSupport::TestCase
+  test "passing on the request id from the outside" do
+    assert_equal "external-uu-rid", stub_request('HTTP_X_REQUEST_ID' => 'external-uu-rid').uuid
+  end
+
+  test "ensure that only alphanumeric uurids are accepted" do
+    assert_equal "X-Hacked-HeaderStuff", stub_request('HTTP_X_REQUEST_ID' => '; X-Hacked-Header: Stuff').uuid
+  end
+
+  test "ensure that 255 char limit on the request id is being enforced" do
+    assert_equal "X" * 255, stub_request('HTTP_X_REQUEST_ID' => 'X' * 500).uuid
+  end
+
+  test "generating a request id when none is supplied" do
+    assert_match(/\w+/, stub_request.uuid)
+  end
+
+  private
+
+  def stub_request(env = {})
+    ActionDispatch::RequestId.new(lambda { |environment| [ 200, environment, [] ] }).call(env)
+    ActionDispatch::Request.new(env)
+  end
+end
+
+class RequestIdResponseTest < ActionDispatch::IntegrationTest
+  class TestController < ActionController::Base
+    def index
+      head :ok
+    end
+  end
+
+  test "request id is passed all the way to the response" do
+    with_test_route_set do
+      get '/'
+      assert_match(/\w+/, @response.headers["X-Request-Id"])
+    end
+  end
+
+  test "request id given on request is passed all the way to the response" do
+    with_test_route_set do
+      get '/', {}, 'HTTP_X_REQUEST_ID' => 'X' * 500
+      assert_equal "X" * 255, @response.headers["X-Request-Id"]
+    end
+  end
+
+
+  private
+
+  def with_test_route_set
+    with_routing do |set|
+      set.draw do
+        match '/', :to => ::RequestIdResponseTest::TestController.action(:index)
+      end
+
+      @app = self.class.build_app(set) do |middleware|
+        middleware.use ActionDispatch::RequestId
+      end
+
+      yield
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/test/dispatch/request_test.rb b/actionpack/test/dispatch/request_test.rb
index 060bcfb5ec..4d805464c2 100644
--- a/actionpack/test/dispatch/request_test.rb
+++ b/actionpack/test/dispatch/request_test.rb
@@ -15,6 +15,7 @@ class RequestTest < ActiveSupport::TestCase
 
     assert_equal 'http://www.example.com',  url_for
     assert_equal 'http://api.example.com',  url_for(:subdomain => 'api')
+    assert_equal 'http://example.com',      url_for(:subdomain => false)
     assert_equal 'http://www.ror.com',      url_for(:domain => 'ror.com')
     assert_equal 'http://api.ror.co.uk',    url_for(:host => 'www.ror.co.uk', :subdomain => 'api', :tld_length => 2)
     assert_equal 'http://www.example.com:8080',   url_for(:port => 8080)
@@ -35,7 +36,7 @@ class RequestTest < ActiveSupport::TestCase
 
     request = stub_request 'REMOTE_ADDR' => '1.2.3.4',
       'HTTP_X_FORWARDED_FOR' => '3.4.5.6'
-    assert_equal '1.2.3.4', request.remote_ip
+    assert_equal '3.4.5.6', request.remote_ip
 
     request = stub_request 'REMOTE_ADDR' => '127.0.0.1',
       'HTTP_X_FORWARDED_FOR' => '3.4.5.6'
@@ -88,6 +89,11 @@ class RequestTest < ActiveSupport::TestCase
     assert_equal '9.9.9.9', request.remote_ip
   end
 
+  test "remote ip when the remote ip middleware returns nil" do
+    request = stub_request 'REMOTE_ADDR' => '127.0.0.1'
+    assert_equal '127.0.0.1', request.remote_ip
+  end
+
   test "remote ip with user specified trusted proxies" do
     @trusted_proxies = /^67\.205\.106\.73$/i
 
@@ -105,7 +111,7 @@ class RequestTest < ActiveSupport::TestCase
 
     request = stub_request 'REMOTE_ADDR' => '67.205.106.74,172.16.0.1',
                            'HTTP_X_FORWARDED_FOR' => '3.4.5.6'
-    assert_equal '67.205.106.74', request.remote_ip
+    assert_equal '3.4.5.6', request.remote_ip
 
     request = stub_request 'HTTP_X_FORWARDED_FOR' => 'unknown,67.205.106.73'
     assert_equal 'unknown', request.remote_ip
diff --git a/actionpack/test/dispatch/routing_test.rb b/actionpack/test/dispatch/routing_test.rb
index 1938348375..19eee379fd 100644
--- a/actionpack/test/dispatch/routing_test.rb
+++ b/actionpack/test/dispatch/routing_test.rb
@@ -62,13 +62,8 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
       match 'secure', :to => redirect("/secure/login")
 
       match 'mobile', :to => redirect(:subdomain => 'mobile')
-      match 'documentation', :to => redirect(:domain => 'example-documentation.com', :path => '')
-      match 'new_documentation', :to => redirect(:path => '/documentation/new')
       match 'super_new_documentation', :to => redirect(:host => 'super-docs.com')
 
-      match 'stores/:name',        :to => redirect(:subdomain => 'stores', :path => '/%{name}')
-      match 'stores/:name(*rest)', :to => redirect(:subdomain => 'stores', :path => '/%{name}%{rest}')
-
       match 'youtube_favorites/:youtube_id/:name', :to => redirect(YoutubeFavoritesRedirector)
 
       constraints(lambda { |req| true }) do
@@ -79,7 +74,7 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
       match 'sign_in' => "sessions#new"
 
       match 'account/modulo/:name', :to => redirect("/%{name}s")
-      match 'account/proc/:name', :to => redirect {|params| "/#{params[:name].pluralize}" }
+      match 'account/proc/:name', :to => redirect {|params, req| "/#{params[:name].pluralize}" }
       match 'account/proc_req' => redirect {|params, req| "/#{req.method}" }
 
       match 'account/google' => redirect('http://www.google.com/', :status => 302)
@@ -339,6 +334,7 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
       end
 
       scope '(:locale)', :locale => /en|pl/ do
+        get "registrations/new"
         resources :descriptions
         root :to => 'projects#index'
       end
@@ -710,20 +706,6 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
     end
   end
 
-  def test_redirect_hash_with_domain_and_path
-    with_test_routes do
-      get '/documentation'
-      verify_redirect 'http://www.example-documentation.com'
-    end
-  end
-
-  def test_redirect_hash_with_path
-    with_test_routes do
-      get '/new_documentation'
-      verify_redirect 'http://www.example.com/documentation/new'
-    end
-  end
-
   def test_redirect_hash_with_host
     with_test_routes do
       get '/super_new_documentation?section=top'
@@ -731,20 +713,6 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
     end
   end
 
-  def test_redirect_hash_path_substitution
-    with_test_routes do
-      get '/stores/iernest'
-      verify_redirect 'http://stores.example.com/iernest'
-    end
-  end
-
-  def test_redirect_hash_path_substitution_with_catch_all
-    with_test_routes do
-      get '/stores/iernest/products'
-      verify_redirect 'http://stores.example.com/iernest/products'
-    end
-  end
-
   def test_redirect_class
     with_test_routes do
       get '/youtube_favorites/oHg5SJYRHA0/rick-rolld'
@@ -851,6 +819,29 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
     end
   end
 
+  # tests the use of dup in url_for
+  def test_url_for_with_no_side_effects
+    # without dup, additional (and possibly unwanted) values will be present in the options (eg. :host)
+    original_options = {:controller => 'projects', :action => 'status'}
+    options = original_options.dup
+
+    url_for options
+
+    # verify that the options passed in have not changed from the original ones
+    assert_equal original_options, options
+  end
+
+  # tests the arguments modification free version of define_hash_access
+  def test_named_route_with_no_side_effects
+    original_options = { :host => 'test.host' }
+    options = original_options.dup
+
+    profile_customer_url("customer_model", options)
+
+    # verify that the options passed in have not changed from the original ones
+    assert_equal original_options, options
+  end
+
   def test_projects_status
     with_test_routes do
       assert_equal '/projects/status', url_for(:controller => 'projects', :action => 'status', :only_path => true)
@@ -1448,6 +1439,16 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
     end
   end
 
+  def test_nested_optional_path_shorthand
+    with_test_routes do
+      get '/registrations/new'
+      assert @request.params[:locale].nil?
+
+      get '/en/registrations/new'
+      assert 'en', @request.params[:locale]
+    end
+  end
+
   def test_default_params
     with_test_routes do
       get '/inline_pages'
@@ -2298,6 +2299,11 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
     assert_equal "/forced_collision", routes_forced_collision_path
   end
 
+  def test_redirect_argument_error
+    routes = Class.new { include ActionDispatch::Routing::Redirection }.new
+    assert_raises(ArgumentError) { routes.redirect Object.new }
+  end
+
   def test_explicitly_avoiding_the_named_route
     assert !respond_to?(:routes_no_collision_path)
   end
@@ -2494,3 +2500,40 @@ class TestHttpMethods < ActionDispatch::IntegrationTest
     end
   end
 end
+
+class TestUriPathEscaping < ActionDispatch::IntegrationTest
+  Routes = ActionDispatch::Routing::RouteSet.new.tap do |app|
+    app.draw do
+      match '/:segment' => lambda { |env|
+        path_params = env['action_dispatch.request.path_parameters']
+        [200, { 'Content-Type' => 'text/plain' }, [path_params[:segment]]]
+      }, :as => :segment
+
+      match '/*splat' => lambda { |env|
+        path_params = env['action_dispatch.request.path_parameters']
+        [200, { 'Content-Type' => 'text/plain' }, [path_params[:splat]]]
+      }, :as => :splat
+    end
+  end
+
+  include Routes.url_helpers
+  def app; Routes end
+
+  test 'escapes generated path segment' do
+    assert_equal '/a%20b/c+d', segment_path(:segment => 'a b/c+d')
+  end
+
+  test 'unescapes recognized path segment' do
+    get '/a%20b%2Fc+d'
+    assert_equal 'a b/c+d', @response.body
+  end
+
+  test 'escapes generated path splat' do
+    assert_equal '/a%20b/c+d', splat_path(:splat => 'a b/c+d')
+  end
+
+  test 'unescapes recognized path splat' do
+    get '/a%20b/c+d'
+    assert_equal 'a b/c+d', @response.body
+  end
+end
diff --git a/actionpack/test/dispatch/session/cache_store_test.rb b/actionpack/test/dispatch/session/cache_store_test.rb
new file mode 100644
index 0000000000..73e056de23
--- /dev/null
+++ b/actionpack/test/dispatch/session/cache_store_test.rb
@@ -0,0 +1,181 @@
+require 'abstract_unit'
+
+class CacheStoreTest < ActionDispatch::IntegrationTest
+  class TestController < ActionController::Base
+    def no_session_access
+      head :ok
+    end
+
+    def set_session_value
+      session[:foo] = "bar"
+      head :ok
+    end
+
+    def set_serialized_session_value
+      session[:foo] = SessionAutoloadTest::Foo.new
+      head :ok
+    end
+
+    def get_session_value
+      render :text => "foo: #{session[:foo].inspect}"
+    end
+
+    def get_session_id
+      render :text => "#{request.session_options[:id]}"
+    end
+
+    def call_reset_session
+      session[:bar]
+      reset_session
+      session[:bar] = "baz"
+      head :ok
+    end
+
+    def rescue_action(e) raise end
+  end
+
+  def test_setting_and_getting_session_value
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: "bar"', response.body
+    end
+  end
+
+  def test_getting_nil_session_value
+    with_test_route_set do
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body
+    end
+  end
+
+  def test_getting_session_value_after_session_reset
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+      session_cookie = cookies.send(:hash_for)['_session_id']
+
+      get '/call_reset_session'
+      assert_response :success
+      assert_not_equal [], headers['Set-Cookie']
+
+      cookies << session_cookie # replace our new session_id with our old, pre-reset session_id
+
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body, "data for this session should have been obliterated from cache"
+    end
+  end
+
+  def test_getting_from_nonexistent_session
+    with_test_route_set do
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body
+      assert_nil cookies['_session_id'], "should only create session on write, not read"
+    end
+  end
+
+  def test_setting_session_value_after_session_reset
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+      session_id = cookies['_session_id']
+
+      get '/call_reset_session'
+      assert_response :success
+      assert_not_equal [], headers['Set-Cookie']
+
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body
+
+      get '/get_session_id'
+      assert_response :success
+      assert_not_equal session_id, response.body
+    end
+  end
+
+  def test_getting_session_id
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+      session_id = cookies['_session_id']
+
+      get '/get_session_id'
+      assert_response :success
+      assert_equal session_id, response.body, "should be able to read session id without accessing the session hash"
+    end
+  end
+
+  def test_deserializes_unloaded_class
+    with_test_route_set do
+      with_autoload_path "session_autoload_test" do
+        get '/set_serialized_session_value'
+        assert_response :success
+        assert cookies['_session_id']
+      end
+      with_autoload_path "session_autoload_test" do
+        get '/get_session_id'
+        assert_response :success
+      end
+      with_autoload_path "session_autoload_test" do
+        get '/get_session_value'
+        assert_response :success
+        assert_equal 'foo: #<SessionAutoloadTest::Foo bar:"baz">', response.body, "should auto-load unloaded class"
+      end
+    end
+  end
+
+  def test_doesnt_write_session_cookie_if_session_id_is_already_exists
+    with_test_route_set do
+      get '/set_session_value'
+      assert_response :success
+      assert cookies['_session_id']
+
+      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"
+    end
+  end
+
+  def test_prevents_session_fixation
+    with_test_route_set do
+      get '/get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body
+      session_id = cookies['_session_id']
+
+      reset!
+
+      get '/set_session_value', :_session_id => session_id
+      assert_response :success
+      assert_not_equal session_id, cookies['_session_id']
+    end
+  end
+
+  private
+    def with_test_route_set
+      with_routing do |set|
+        set.draw do
+          match ':action', :to => ::CacheStoreTest::TestController
+        end
+
+        @app = self.class.build_app(set) do |middleware|
+          cache = ActiveSupport::Cache::MemoryStore.new
+          middleware.use ActionDispatch::Session::CacheStore, :key => '_session_id', :cache => cache
+          middleware.delete "ActionDispatch::ShowExceptions"
+        end
+
+        yield
+      end
+    end
+end
diff --git a/actionpack/test/dispatch/session/cookie_store_test.rb b/actionpack/test/dispatch/session/cookie_store_test.rb
index 301bf9c6d2..92df6967d6 100644
--- a/actionpack/test/dispatch/session/cookie_store_test.rb
+++ b/actionpack/test/dispatch/session/cookie_store_test.rb
@@ -5,7 +5,7 @@ class CookieStoreTest < ActionDispatch::IntegrationTest
   SessionKey = '_myapp_session'
   SessionSecret = 'b3c631c314c0bbca50c1b2843150fe33'
 
-  Verifier = ActiveSupport::MessageVerifier.new(SessionSecret, 'SHA1')
+  Verifier = ActiveSupport::MessageVerifier.new(SessionSecret, :digest => 'SHA1')
   SignedBar = Verifier.generate(:foo => "bar", :session_id => SecureRandom.hex(16))
 
   class TestController < ActionController::Base
diff --git a/actionpack/test/dispatch/show_exceptions_test.rb b/actionpack/test/dispatch/show_exceptions_test.rb
index 42f6c7f79f..90f13a3bb9 100644
--- a/actionpack/test/dispatch/show_exceptions_test.rb
+++ b/actionpack/test/dispatch/show_exceptions_test.rb
@@ -2,32 +2,38 @@ require 'abstract_unit'
 
 class ShowExceptionsTest < ActionDispatch::IntegrationTest
 
-  Boomer = lambda do |env|
-    req = ActionDispatch::Request.new(env)
-    case req.path
-    when "/not_found"
-      raise ActionController::UnknownAction
-    when "/runtime_error"
-      raise RuntimeError
-    when "/method_not_allowed"
-      raise ActionController::MethodNotAllowed
-    when "/not_implemented"
-      raise ActionController::NotImplemented
-    when "/unprocessable_entity"
-      raise ActionController::InvalidAuthenticityToken
-    when "/not_found_original_exception"
-      raise ActionView::Template::Error.new('template', {}, AbstractController::ActionNotFound.new)
-    else
-      raise "puke!"
+  class Boomer
+    def initialize(detailed  = false)
+      @detailed = detailed
+    end
+
+    def call(env)
+      env['action_dispatch.show_detailed_exceptions'] = @detailed
+      req = ActionDispatch::Request.new(env)
+      case req.path
+      when "/not_found"
+        raise ActionController::UnknownAction
+      when "/runtime_error"
+        raise RuntimeError
+      when "/method_not_allowed"
+        raise ActionController::MethodNotAllowed
+      when "/not_implemented"
+        raise ActionController::NotImplemented
+      when "/unprocessable_entity"
+        raise ActionController::InvalidAuthenticityToken
+      when "/not_found_original_exception"
+        raise ActionView::Template::Error.new('template', {}, AbstractController::ActionNotFound.new)
+      else
+        raise "puke!"
+      end
     end
   end
 
-  ProductionApp = ActionDispatch::ShowExceptions.new(Boomer, false)
-  DevelopmentApp = ActionDispatch::ShowExceptions.new(Boomer, true)
+  ProductionApp = ActionDispatch::ShowExceptions.new(Boomer.new(false))
+  DevelopmentApp = ActionDispatch::ShowExceptions.new(Boomer.new(true))
 
-  test "rescue in public from a remote ip" do
+  test "rescue with error page when show_exceptions is false" do
     @app = ProductionApp
-    self.remote_addr = '208.77.188.166'
 
     get "/", {}, {'action_dispatch.show_exceptions' => true}
     assert_response 500
@@ -42,32 +48,28 @@ class ShowExceptionsTest < ActionDispatch::IntegrationTest
     assert_equal "", body
   end
 
-  test "rescue locally from a local request" do
-    @app = ProductionApp
-    ['127.0.0.1', '127.0.0.127', '::1', '0:0:0:0:0:0:0:1', '0:0:0:0:0:0:0:1%0'].each do |ip_address|
-      self.remote_addr = ip_address
+  test "rescue with diagnostics message when show_exceptions is true" do
+    @app = DevelopmentApp
 
-      get "/", {}, {'action_dispatch.show_exceptions' => true}
-      assert_response 500
-      assert_match(/puke/, body)
+    get "/", {}, {'action_dispatch.show_exceptions' => true}
+    assert_response 500
+    assert_match(/puke/, body)
 
-      get "/not_found", {}, {'action_dispatch.show_exceptions' => true}
-      assert_response 404
-      assert_match(/#{ActionController::UnknownAction.name}/, body)
+    get "/not_found", {}, {'action_dispatch.show_exceptions' => true}
+    assert_response 404
+    assert_match(/#{ActionController::UnknownAction.name}/, body)
 
-      get "/method_not_allowed", {}, {'action_dispatch.show_exceptions' => true}
-      assert_response 405
-      assert_match(/ActionController::MethodNotAllowed/, body)
-    end
+    get "/method_not_allowed", {}, {'action_dispatch.show_exceptions' => true}
+    assert_response 405
+    assert_match(/ActionController::MethodNotAllowed/, body)
   end
 
-  test "localize public rescue message" do
+  test "localize rescue error page" do
     # Change locale
     old_locale, I18n.locale = I18n.locale, :da
 
     begin
       @app = ProductionApp
-      self.remote_addr = '208.77.188.166'
 
       get "/", {}, {'action_dispatch.show_exceptions' => true}
       assert_response 500
@@ -81,23 +83,6 @@ class ShowExceptionsTest < ActionDispatch::IntegrationTest
     end
   end
 
-  test "always rescue locally in development mode" do
-    @app = DevelopmentApp
-    self.remote_addr = '208.77.188.166'
-
-    get "/", {}, {'action_dispatch.show_exceptions' => true}
-    assert_response 500
-    assert_match(/puke/, body)
-
-    get "/not_found", {}, {'action_dispatch.show_exceptions' => true}
-    assert_response 404
-    assert_match(/#{ActionController::UnknownAction.name}/, body)
-
-    get "/method_not_allowed", {}, {'action_dispatch.show_exceptions' => true}
-    assert_response 405
-    assert_match(/ActionController::MethodNotAllowed/, body)
-  end
-
   test "does not show filtered parameters" do
     @app = DevelopmentApp
 
@@ -107,16 +92,15 @@ class ShowExceptionsTest < ActionDispatch::IntegrationTest
     assert_match("&quot;foo&quot;=&gt;&quot;[FILTERED]&quot;", body)
   end
 
-  test "show registered original exception for wrapped exceptions when consider_all_requests_local is false" do
+  test "show registered original exception for wrapped exceptions when show_exceptions is false" do
     @app = ProductionApp
-    self.remote_addr = '208.77.188.166'
 
     get "/not_found_original_exception", {}, {'action_dispatch.show_exceptions' => true}
     assert_response 404
     assert_match(/404 error/, body)
   end
 
-  test "show registered original exception for wrapped exceptions when consider_all_requests_local is true" do
+  test "show registered original exception for wrapped exceptions when show_exceptions is true" do
     @app = DevelopmentApp
 
     get "/not_found_original_exception", {}, {'action_dispatch.show_exceptions' => true}
@@ -125,7 +109,7 @@ class ShowExceptionsTest < ActionDispatch::IntegrationTest
   end
 
   test "show the controller name in the diagnostics template when controller name is present" do
-    @app = ProductionApp
+    @app = DevelopmentApp
     get("/runtime_error", {}, {
       'action_dispatch.show_exceptions' => true,
       'action_dispatch.request.parameters' => {
@@ -144,4 +128,18 @@ class ShowExceptionsTest < ActionDispatch::IntegrationTest
     get "/", {}, {'action_dispatch.show_exceptions' => true}
     assert_equal "text/html; charset=utf-8", response.headers["Content-Type"]
   end
+
+  test 'uses logger from env' do
+    @app = ProductionApp
+    output = StringIO.new
+    get "/", {}, {'action_dispatch.show_exceptions' => true, 'action_dispatch.logger' => Logger.new(output)}
+    assert_match(/puke/, output.rewind && output.read)
+  end
+
+  test 'uses backtrace cleaner from env' do
+    @app = DevelopmentApp
+    cleaner = stub(:clean => ['passed backtrace cleaner'])
+    get "/", {}, {'action_dispatch.show_exceptions' => true, 'action_dispatch.backtrace_cleaner' => cleaner}
+    assert_match(/passed backtrace cleaner/, body)
+  end
 end