Merge branch 'master' into nested_has_many_through

Conflicts:
	activerecord/CHANGELOG
	activerecord/lib/active_record/association_preload.rb
	activerecord/lib/active_record/associations.rb
	activerecord/lib/active_record/associations/class_methods/join_dependency.rb
	activerecord/lib/active_record/associations/class_methods/join_dependency/join_association.rb
	activerecord/lib/active_record/associations/has_many_association.rb
	activerecord/lib/active_record/associations/has_many_through_association.rb
	activerecord/lib/active_record/associations/has_one_association.rb
	activerecord/lib/active_record/associations/has_one_through_association.rb
	activerecord/lib/active_record/associations/through_association_scope.rb
	activerecord/lib/active_record/reflection.rb
	activerecord/test/cases/associations/has_many_through_associations_test.rb
	activerecord/test/cases/associations/has_one_through_associations_test.rb
	activerecord/test/cases/reflection_test.rb
	activerecord/test/cases/relations_test.rb
	activerecord/test/fixtures/memberships.yml
	activerecord/test/models/categorization.rb
	activerecord/test/models/category.rb
	activerecord/test/models/member.rb
	activerecord/test/models/reference.rb
	activerecord/test/models/tagging.rb

10 files changed, 528 insertions, 67 deletions

diff --git a/actionpack/test/dispatch/callbacks_test.rb b/actionpack/test/dispatch/callbacks_test.rb
index d3aa55a1ba..eed2eca2ab 100644
--- a/actionpack/test/dispatch/callbacks_test.rb
+++ b/actionpack/test/dispatch/callbacks_test.rb
@@ -1,6 +1,6 @@
 require 'abstract_unit'
 
-class DispatcherTest < Test::Unit::TestCase
+class DispatcherTest < ActiveSupport::TestCase
   class Foo
     cattr_accessor :a, :b
   end
@@ -13,65 +13,9 @@ class DispatcherTest < Test::Unit::TestCase
 
   def setup
     Foo.a, Foo.b = 0, 0
-    ActionDispatch::Callbacks.reset_callbacks(:prepare)
     ActionDispatch::Callbacks.reset_callbacks(:call)
   end
 
-  def test_prepare_callbacks_with_cache_classes
-    a = b = c = nil
-    ActionDispatch::Callbacks.to_prepare { |*args| a = b = c = 1 }
-    ActionDispatch::Callbacks.to_prepare { |*args| b = c = 2 }
-    ActionDispatch::Callbacks.to_prepare { |*args| c = 3 }
-
-    # Ensure to_prepare callbacks are not run when defined
-    assert_nil a || b || c
-
-    # Run callbacks
-    dispatch
-
-    assert_equal 1, a
-    assert_equal 2, b
-    assert_equal 3, c
-
-    # Make sure they are only run once
-    a = b = c = nil
-    dispatch
-    assert_nil a || b || c
-  end
-
-  def test_prepare_callbacks_without_cache_classes
-    a = b = c = nil
-    ActionDispatch::Callbacks.to_prepare { |*args| a = b = c = 1 }
-    ActionDispatch::Callbacks.to_prepare { |*args| b = c = 2 }
-    ActionDispatch::Callbacks.to_prepare { |*args| c = 3 }
-
-    # Ensure to_prepare callbacks are not run when defined
-    assert_nil a || b || c
-
-    # Run callbacks
-    dispatch(false)
-
-    assert_equal 1, a
-    assert_equal 2, b
-    assert_equal 3, c
-
-    # Make sure they are run again
-    a = b = c = nil
-    dispatch(false)
-    assert_equal 1, a
-    assert_equal 2, b
-    assert_equal 3, c
-  end
-
-  def test_to_prepare_with_identifier_replaces
-    ActionDispatch::Callbacks.to_prepare(:unique_id) { |*args| Foo.a, Foo.b = 1, 1 }
-    ActionDispatch::Callbacks.to_prepare(:unique_id) { |*args| Foo.a = 2 }
-
-    dispatch
-    assert_equal 2, Foo.a
-    assert_equal 0, Foo.b
-  end
-
   def test_before_and_after_callbacks
     ActionDispatch::Callbacks.before { |*args| Foo.a += 1; Foo.b += 1 }
     ActionDispatch::Callbacks.after  { |*args| Foo.a += 1; Foo.b += 1 }
@@ -85,10 +29,22 @@ class DispatcherTest < Test::Unit::TestCase
     assert_equal 4, Foo.b
   end
 
+  def test_to_prepare_and_cleanup_delegation
+    prepared = cleaned = false
+    ActionDispatch::Callbacks.to_prepare { prepared = true }
+    ActionDispatch::Callbacks.to_prepare { cleaned = true }
+
+    ActionDispatch::Reloader.prepare!
+    assert prepared
+
+    ActionDispatch::Reloader.cleanup!
+    assert cleaned
+  end
+
   private
 
-    def dispatch(cache_classes = true, &block)
-      @dispatcher ||= ActionDispatch::Callbacks.new(block || DummyApp.new, !cache_classes)
+    def dispatch(&block)
+      @dispatcher ||= ActionDispatch::Callbacks.new(block || DummyApp.new)
       @dispatcher.call({'rack.input' => StringIO.new('')})
     end
 
diff --git a/actionpack/test/dispatch/cookies_test.rb b/actionpack/test/dispatch/cookies_test.rb
index 5ec7f12cc1..1cfea6aa12 100644
--- a/actionpack/test/dispatch/cookies_test.rb
+++ b/actionpack/test/dispatch/cookies_test.rb
@@ -95,6 +95,26 @@ class CookiesTest < ActionController::TestCase
       head :ok
     end
 
+    def set_cookie_with_domain_and_tld
+      cookies[:user_name] = {:value => "rizwanreza", :domain => :all, :tld_length => 2}
+      head :ok
+    end
+
+    def delete_cookie_with_domain_and_tld
+      cookies.delete(:user_name, :domain => :all, :tld_length => 2)
+      head :ok
+    end
+
+    def set_cookie_with_domains
+      cookies[:user_name] = {:value => "rizwanreza", :domain => %w(example1.com example2.com .example3.com)}
+      head :ok
+    end
+
+    def delete_cookie_with_domains
+      cookies.delete(:user_name, :domain => %w(example1.com example2.com .example3.com))
+      head :ok
+    end
+
     def symbol_key
       cookies[:user_name] = "david"
       head :ok
@@ -295,12 +315,94 @@ class CookiesTest < ActionController::TestCase
     assert_cookie_header "user_name=rizwanreza; domain=.nextangle.local; path=/"
   end
 
+  def test_cookie_with_all_domain_option_using_localhost
+    @request.host = "localhost"
+    get :set_cookie_with_domain
+    assert_response :success
+    assert_cookie_header "user_name=rizwanreza; path=/"
+  end
+
+  def test_cookie_with_all_domain_option_using_ipv4_address
+    @request.host = "192.168.1.1"
+    get :set_cookie_with_domain
+    assert_response :success
+    assert_cookie_header "user_name=rizwanreza; path=/"
+  end
+
+  def test_cookie_with_all_domain_option_using_ipv6_address
+    @request.host = "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
+    get :set_cookie_with_domain
+    assert_response :success
+    assert_cookie_header "user_name=rizwanreza; path=/"
+  end
+
   def test_deleting_cookie_with_all_domain_option
     get :delete_cookie_with_domain
     assert_response :success
     assert_cookie_header "user_name=; domain=.nextangle.com; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT"
   end
 
+  def test_cookie_with_all_domain_option_and_tld_length
+    get :set_cookie_with_domain_and_tld
+    assert_response :success
+    assert_cookie_header "user_name=rizwanreza; domain=.nextangle.com; path=/"
+  end
+
+  def test_cookie_with_all_domain_option_using_a_non_standard_tld_and_tld_length
+    @request.host = "two.subdomains.nextangle.local"
+    get :set_cookie_with_domain_and_tld
+    assert_response :success
+    assert_cookie_header "user_name=rizwanreza; domain=.nextangle.local; path=/"
+  end
+
+  def test_cookie_with_all_domain_option_using_host_with_port_and_tld_length
+    @request.host = "nextangle.local:3000"
+    get :set_cookie_with_domain_and_tld
+    assert_response :success
+    assert_cookie_header "user_name=rizwanreza; domain=.nextangle.local; path=/"
+  end
+
+  def test_deleting_cookie_with_all_domain_option_and_tld_length
+    get :delete_cookie_with_domain_and_tld
+    assert_response :success
+    assert_cookie_header "user_name=; domain=.nextangle.com; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT"
+  end
+
+  def test_cookie_with_several_preset_domains_using_one_of_these_domains
+    @request.host = "example1.com"
+    get :set_cookie_with_domains
+    assert_response :success
+    assert_cookie_header "user_name=rizwanreza; domain=example1.com; path=/"
+  end
+
+  def test_cookie_with_several_preset_domains_using_other_domain
+    @request.host = "other-domain.com"
+    get :set_cookie_with_domains
+    assert_response :success
+    assert_cookie_header "user_name=rizwanreza; path=/"
+  end
+
+  def test_cookie_with_several_preset_domains_using_shared_domain
+    @request.host = "example3.com"
+    get :set_cookie_with_domains
+    assert_response :success
+    assert_cookie_header "user_name=rizwanreza; domain=.example3.com; path=/"
+  end
+
+  def test_deletings_cookie_with_several_preset_domains_using_one_of_these_domains
+    @request.host = "example2.com"
+    get :delete_cookie_with_domains
+    assert_response :success
+    assert_cookie_header "user_name=; domain=example2.com; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT"
+  end
+
+  def test_deletings_cookie_with_several_preset_domains_using_other_domain
+    @request.host = "other-domain.com"
+    get :delete_cookie_with_domains
+    assert_response :success
+    assert_cookie_header "user_name=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT"
+  end
+
   def test_cookies_hash_is_indifferent_access
     [:symbol_key, :string_key].each do |cookie_key|
       get cookie_key
diff --git a/actionpack/test/dispatch/middleware_stack/middleware_test.rb b/actionpack/test/dispatch/middleware_stack/middleware_test.rb
new file mode 100644
index 0000000000..9607f026db
--- /dev/null
+++ b/actionpack/test/dispatch/middleware_stack/middleware_test.rb
@@ -0,0 +1,77 @@
+require 'abstract_unit'
+require 'action_dispatch/middleware/stack'
+
+module ActionDispatch
+  class MiddlewareStack
+    class MiddlewareTest < ActiveSupport::TestCase
+      class Omg; end
+
+      {
+        'concrete'  => Omg,
+        'anonymous' => Class.new
+      }.each do |name, klass|
+
+        define_method("test_#{name}_klass") do
+          mw = Middleware.new klass
+          assert_equal klass, mw.klass
+        end
+
+        define_method("test_#{name}_==") do
+          mw1 = Middleware.new klass
+          mw2 = Middleware.new klass
+          assert_equal mw1, mw2
+        end
+
+      end
+
+      def test_string_class
+        mw = Middleware.new Omg.name
+        assert_equal Omg, mw.klass
+      end
+
+      def test_double_equal_works_with_classes
+        k = Class.new
+        mw = Middleware.new k
+        assert_operator mw, :==, k
+
+        result = mw != Class.new
+        assert result, 'middleware should not equal other anon class'
+      end
+
+      def test_double_equal_works_with_strings
+        mw = Middleware.new Omg
+        assert_operator mw, :==, Omg.name
+      end
+
+      def test_double_equal_normalizes_strings
+        mw = Middleware.new Omg
+        assert_operator mw, :==, "::#{Omg.name}"
+      end
+
+      def test_middleware_loads_classnames_from_cache
+        mw = Class.new(Middleware) {
+          attr_accessor :classcache
+        }.new(Omg.name)
+
+        fake_cache    = { mw.name => Omg }
+        mw.classcache = fake_cache
+
+        assert_equal Omg, mw.klass
+
+        fake_cache[mw.name] = Middleware
+        assert_equal Middleware, mw.klass
+      end
+
+      def test_middleware_always_returns_class
+        mw = Class.new(Middleware) {
+          attr_accessor :classcache
+        }.new(Omg)
+
+        fake_cache    = { mw.name => Middleware }
+        mw.classcache = fake_cache
+
+        assert_equal Omg, mw.klass
+      end
+    end
+  end
+end
diff --git a/actionpack/test/dispatch/mime_type_test.rb b/actionpack/test/dispatch/mime_type_test.rb
index 9782f328fc..11cf68fdb3 100644
--- a/actionpack/test/dispatch/mime_type_test.rb
+++ b/actionpack/test/dispatch/mime_type_test.rb
@@ -131,6 +131,13 @@ class MimeTypeTest < ActiveSupport::TestCase
     assert unverified.each { |type| assert !Mime.const_get(type.to_s.upcase).verify_request?, "Nonverifiable Mime Type is verified: #{type.inspect}" }
   end
 
+  test "references gives preference to symbols before strings" do
+    assert_equal :html, Mime::HTML.ref
+    another = Mime::Type.lookup("foo/bar")
+    assert_nil another.to_sym
+    assert_equal "foo/bar", another.ref
+  end
+
   test "regexp matcher" do
     assert Mime::JS =~ "text/javascript"
     assert Mime::JS =~ "application/javascript"
diff --git a/actionpack/test/dispatch/reloader_test.rb b/actionpack/test/dispatch/reloader_test.rb
new file mode 100644
index 0000000000..eaabc1feb3
--- /dev/null
+++ b/actionpack/test/dispatch/reloader_test.rb
@@ -0,0 +1,138 @@
+require 'abstract_unit'
+
+class ReloaderTest < Test::Unit::TestCase
+  Reloader = ActionDispatch::Reloader
+
+  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
+
+  class MyBody < Array
+    def initialize(&block)
+      @on_close = block
+    end
+
+    def foo
+      "foo"
+    end
+
+    def bar
+      "bar"
+    end
+
+    def close
+      @on_close.call if @on_close
+    end
+  end
+
+  def test_returned_body_object_always_responds_to_close
+    body = call_and_return_body
+    assert_respond_to body, :close
+  end
+
+  def test_returned_body_object_behaves_like_underlying_object
+    body = call_and_return_body do
+      b = MyBody.new
+      b << "hello"
+      b << "world"
+      [200, { "Content-Type" => "text/html" }, b]
+    end
+    assert_equal 2, body.size
+    assert_equal "hello", body[0]
+    assert_equal "world", body[1]
+    assert_equal "foo", body.foo
+    assert_equal "bar", body.bar
+  end
+
+  def test_it_calls_close_on_underlying_object_when_close_is_called_on_body
+    close_called = false
+    body = call_and_return_body do
+      b = MyBody.new do
+        close_called = true
+      end
+      [200, { "Content-Type" => "text/html" }, b]
+    end
+    body.close
+    assert close_called
+  end
+
+  def test_returned_body_object_responds_to_all_methods_supported_by_underlying_object
+    body = call_and_return_body do
+      [200, { "Content-Type" => "text/html" }, MyBody.new]
+    end
+    assert_respond_to body, :size
+    assert_respond_to body, :each
+    assert_respond_to body, :foo
+    assert_respond_to body, :bar
+  end
+
+  def test_cleanup_callbacks_are_called_when_body_is_closed
+    cleaned = false
+    Reloader.to_cleanup { cleaned = true }
+
+    body = call_and_return_body
+    assert !cleaned
+
+    body.close
+    assert cleaned
+  end
+
+  def test_prepare_callbacks_arent_called_when_body_is_closed
+    prepared = false
+    Reloader.to_prepare { prepared = true }
+
+    body = call_and_return_body
+    prepared = false
+
+    body.close
+    assert !prepared
+  end
+
+  def test_manual_reloading
+    prepared = cleaned = false
+    Reloader.to_prepare { prepared = true }
+    Reloader.to_cleanup { cleaned  = true }
+
+    Reloader.prepare!
+    assert prepared
+    assert !cleaned
+
+    prepared = cleaned = false
+    Reloader.cleanup!
+    assert !prepared
+    assert cleaned
+  end
+
+  def test_cleanup_callbacks_are_called_on_exceptions
+    cleaned = false
+    Reloader.to_cleanup { cleaned  = true }
+
+    begin
+      call_and_return_body do
+        raise "error"
+      end
+    rescue
+    end
+
+    assert cleaned
+  end
+
+  private
+    def call_and_return_body(&block)
+      @reloader ||= Reloader.new(block || proc {[200, {}, 'response']})
+      @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 75b674ec1a..dd5bf5ec2d 100644
--- a/actionpack/test/dispatch/request_test.rb
+++ b/actionpack/test/dispatch/request_test.rb
@@ -427,7 +427,7 @@ class RequestTest < ActiveSupport::TestCase
     begin
       request = stub_request(mock_rack_env)
       request.parameters
-    rescue TypeError => e
+    rescue TypeError
       # rack will raise a TypeError when parsing this query string
     end
     assert_equal({}, request.parameters)
diff --git a/actionpack/test/dispatch/response_test.rb b/actionpack/test/dispatch/response_test.rb
index ab26d1a645..6f38714b2e 100644
--- a/actionpack/test/dispatch/response_test.rb
+++ b/actionpack/test/dispatch/response_test.rb
@@ -18,7 +18,7 @@ class ResponseTest < ActiveSupport::TestCase
     body.each { |part| parts << part }
     assert_equal ["Hello, World!"], parts
   end
-  
+
   test "status handled properly in initialize" do
     assert_equal 200, ActionDispatch::Response.new('200 OK').status
   end
@@ -26,7 +26,7 @@ class ResponseTest < ActiveSupport::TestCase
   test "utf8 output" do
     @response.body = [1090, 1077, 1089, 1090].pack("U*")
 
-    status, headers, body = @response.to_a
+    status, headers, _ = @response.to_a
     assert_equal 200, status
     assert_equal({
       "Content-Type" => "text/html; charset=utf-8"
@@ -52,20 +52,20 @@ class ResponseTest < ActiveSupport::TestCase
   test "content type" do
     [204, 304].each do |c|
       @response.status = c.to_s
-      status, headers, body = @response.to_a
+      _, headers, _ = @response.to_a
       assert !headers.has_key?("Content-Type"), "#{c} should not have Content-Type header"
     end
 
     [200, 302, 404, 500].each do |c|
       @response.status = c.to_s
-      status, headers, body = @response.to_a
+      _, headers, _ = @response.to_a
       assert headers.has_key?("Content-Type"), "#{c} did not have Content-Type header"
     end
   end
 
   test "does not include Status header" do
     @response.status = "200 OK"
-    status, headers, body = @response.to_a
+    _, headers, _ = @response.to_a
     assert !headers.has_key?('Status')
   end
 
diff --git a/actionpack/test/dispatch/routing_assertions_test.rb b/actionpack/test/dispatch/routing_assertions_test.rb
new file mode 100644
index 0000000000..9f95d82129
--- /dev/null
+++ b/actionpack/test/dispatch/routing_assertions_test.rb
@@ -0,0 +1,103 @@
+require 'abstract_unit'
+require 'controller/fake_controllers'
+
+class SecureArticlesController < ArticlesController; end
+class BlockArticlesController < ArticlesController; end
+
+class RoutingAssertionsTest < ActionController::TestCase
+
+  def setup
+    @routes = ActionDispatch::Routing::RouteSet.new
+    @routes.draw do
+      resources :articles
+
+      scope 'secure', :constraints => { :protocol => 'https://' } do
+        resources :articles, :controller => 'secure_articles'
+      end
+
+      scope 'block', :constraints => lambda { |r| r.ssl? } do
+        resources :articles, :controller => 'block_articles'
+      end
+    end
+  end
+
+  def test_assert_generates
+    assert_generates('/articles', { :controller => 'articles', :action => 'index' })
+    assert_generates('/articles/1', { :controller => 'articles', :action => 'show', :id => '1' })
+  end
+
+  def test_assert_generates_with_defaults
+    assert_generates('/articles/1/edit', { :controller => 'articles', :action => 'edit' }, { :id => '1' })
+  end
+
+  def test_assert_generates_with_extras
+    assert_generates('/articles', { :controller => 'articles', :action => 'index', :page => '1' }, {}, { :page => '1' })
+  end
+
+  def test_assert_recognizes
+    assert_recognizes({ :controller => 'articles', :action => 'index' }, '/articles')
+    assert_recognizes({ :controller => 'articles', :action => 'show', :id => '1' }, '/articles/1')
+  end
+
+  def test_assert_recognizes_with_extras
+    assert_recognizes({ :controller => 'articles', :action => 'index', :page => '1' }, '/articles', { :page => '1' })
+  end
+ 
+  def test_assert_recognizes_with_method
+    assert_recognizes({ :controller => 'articles', :action => 'create' }, { :path => '/articles', :method => :post })
+    assert_recognizes({ :controller => 'articles', :action => 'update', :id => '1' }, { :path => '/articles/1', :method => :put })
+  end
+
+  def test_assert_recognizes_with_hash_constraint
+    assert_raise(ActionController::RoutingError) do
+      assert_recognizes({ :controller => 'secure_articles', :action => 'index' }, 'http://test.host/secure/articles')
+    end
+    assert_recognizes({ :controller => 'secure_articles', :action => 'index' }, 'https://test.host/secure/articles')
+  end
+
+  def test_assert_recognizes_with_block_constraint
+    assert_raise(ActionController::RoutingError) do
+      assert_recognizes({ :controller => 'block_articles', :action => 'index' }, 'http://test.host/block/articles')
+    end
+    assert_recognizes({ :controller => 'block_articles', :action => 'index' }, 'https://test.host/block/articles')
+  end
+
+  def test_assert_routing
+    assert_routing('/articles', :controller => 'articles', :action => 'index')
+  end
+
+  def test_assert_routing_with_defaults
+    assert_routing('/articles/1/edit', { :controller => 'articles', :action => 'edit', :id => '1' }, { :id => '1' })
+  end
+
+  def test_assert_routing_with_extras
+    assert_routing('/articles', { :controller => 'articles', :action => 'index', :page => '1' }, { }, { :page => '1' })
+  end
+
+  def test_assert_routing_with_hash_constraint
+    assert_raise(ActionController::RoutingError) do
+      assert_routing('http://test.host/secure/articles', { :controller => 'secure_articles', :action => 'index' })
+    end
+    assert_routing('https://test.host/secure/articles', { :controller => 'secure_articles', :action => 'index' })
+  end
+
+  def test_assert_routing_with_block_constraint
+    assert_raise(ActionController::RoutingError) do
+      assert_routing('http://test.host/block/articles', { :controller => 'block_articles', :action => 'index' })
+    end
+    assert_routing('https://test.host/block/articles', { :controller => 'block_articles', :action => 'index' })
+  end
+
+  def test_with_routing
+    with_routing do |routes|
+      routes.draw do
+        resources :articles, :path => 'artikel'
+      end
+
+      assert_routing('/artikel', :controller => 'articles', :action => 'index')
+      assert_raise(ActionController::RoutingError) do
+        assert_routing('/articles', { :controller => 'articles', :action => 'index' })
+      end
+    end
+  end
+end
diff --git a/actionpack/test/dispatch/routing_test.rb b/actionpack/test/dispatch/routing_test.rb
index 4bf7880294..1a96587836 100644
--- a/actionpack/test/dispatch/routing_test.rb
+++ b/actionpack/test/dispatch/routing_test.rb
@@ -187,7 +187,12 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
       end
 
       resources :posts, :only => [:index, :show] do
-        resources :comments, :except => :destroy
+        namespace :admin do
+          root :to => "index#index"
+        end
+        resources :comments, :except => :destroy do
+          get "views" => "comments#views", :as => :views
+        end
       end
 
       resource  :past, :only => :destroy
@@ -205,6 +210,14 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
         end
       end
 
+      scope '/hello' do
+        shallow do
+          resources :notes do
+            resources :trackbacks
+          end
+        end
+      end
+
       resources :threads, :shallow => true do
         resource :owner
         resources :messages do
@@ -1676,6 +1689,60 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
     end
   end
 
+  def test_shallow_nested_resources_within_scope
+    with_test_routes do
+
+      get '/hello/notes/1/trackbacks'
+      assert_equal 'trackbacks#index', @response.body
+      assert_equal '/hello/notes/1/trackbacks', note_trackbacks_path(:note_id => 1)
+
+      get '/hello/notes/1/edit'
+      assert_equal 'notes#edit', @response.body
+      assert_equal '/hello/notes/1/edit', edit_note_path(:id => '1')
+
+      get '/hello/notes/1/trackbacks/new'
+      assert_equal 'trackbacks#new', @response.body
+      assert_equal '/hello/notes/1/trackbacks/new', new_note_trackback_path(:note_id => 1)
+
+      get '/hello/trackbacks/1'
+      assert_equal 'trackbacks#show', @response.body
+      assert_equal '/hello/trackbacks/1', trackback_path(:id => '1')
+
+      get '/hello/trackbacks/1/edit'
+      assert_equal 'trackbacks#edit', @response.body
+      assert_equal '/hello/trackbacks/1/edit', edit_trackback_path(:id => '1')
+
+      put '/hello/trackbacks/1'
+      assert_equal 'trackbacks#update', @response.body
+
+      post '/hello/notes/1/trackbacks'
+      assert_equal 'trackbacks#create', @response.body
+
+      delete '/hello/trackbacks/1'
+      assert_equal 'trackbacks#destroy', @response.body
+
+      get '/hello/notes'
+      assert_equal 'notes#index', @response.body
+
+      post '/hello/notes'
+      assert_equal 'notes#create', @response.body
+
+      get '/hello/notes/new'
+      assert_equal 'notes#new', @response.body
+      assert_equal '/hello/notes/new', new_note_path
+
+      get '/hello/notes/1'
+      assert_equal 'notes#show', @response.body
+      assert_equal '/hello/notes/1', note_path(:id => 1)
+
+      put '/hello/notes/1'
+      assert_equal 'notes#update', @response.body
+
+      delete '/hello/notes/1'
+      assert_equal 'notes#destroy', @response.body
+    end
+  end
+
   def test_custom_resource_routes_are_scoped
     with_test_routes do
       assert_equal '/customers/recent', recent_customers_path
@@ -2246,6 +2313,18 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
     end
   end
 
+  def test_nested_route_in_nested_resource
+    get "/posts/1/comments/2/views"
+    assert_equal "comments#views", @response.body
+    assert_equal "/posts/1/comments/2/views", post_comment_views_path(:post_id => '1', :comment_id => '2')
+  end
+
+  def test_root_in_deeply_nested_scope
+    get "/posts/1/admin"
+    assert_equal "admin/index#index", @response.body
+    assert_equal "/posts/1/admin", post_admin_root_path(:post_id => '1')
+  end
+
 private
   def with_test_routes
     yield
diff --git a/actionpack/test/dispatch/session/cookie_store_test.rb b/actionpack/test/dispatch/session/cookie_store_test.rb
index 256d0781c7..27f55fd7ab 100644
--- a/actionpack/test/dispatch/session/cookie_store_test.rb
+++ b/actionpack/test/dispatch/session/cookie_store_test.rb
@@ -194,7 +194,6 @@ class CookieStoreTest < ActionDispatch::IntegrationTest
     with_test_route_set do
       get '/set_session_value'
       assert_response :success
-      session_payload = response.body
       assert_equal "_myapp_session=#{response.body}; path=/; HttpOnly",
         headers['Set-Cookie']