Merge branch 'master' of git@github.com:rails/rails

9 files changed, 252 insertions, 85 deletions

diff --git a/actionpack/test/abstract_unit.rb b/actionpack/test/abstract_unit.rb
index 2ba056e60f..30e2d863d0 100644
--- a/actionpack/test/abstract_unit.rb
+++ b/actionpack/test/abstract_unit.rb
@@ -34,7 +34,6 @@ ActionController::Base.session_store = nil
 
 FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures')
 ActionController::Base.view_paths = FIXTURE_LOAD_PATH
-ActionController::Base.view_paths.load
 
 def uses_mocha(test_name)
   yield
diff --git a/actionpack/test/controller/dispatcher_test.rb b/actionpack/test/controller/dispatcher_test.rb
index fd06b4ea99..da87d26146 100644
--- a/actionpack/test/controller/dispatcher_test.rb
+++ b/actionpack/test/controller/dispatcher_test.rb
@@ -96,9 +96,7 @@ class DispatcherTest < Test::Unit::TestCase
 
   private
     def dispatch(cache_classes = true)
-      controller = mock()
-      controller.stubs(:process).returns([200, {}, 'response'])
-      ActionController::Routing::Routes.stubs(:recognize).returns(controller)
+      ActionController::Routing::RouteSet.any_instance.stubs(:call).returns([200, {}, 'response'])
       Dispatcher.define_dispatcher_callbacks(cache_classes)
       @dispatcher.call({})
     end
diff --git a/actionpack/test/controller/http_digest_authentication_test.rb b/actionpack/test/controller/http_digest_authentication_test.rb
new file mode 100644
index 0000000000..d5c8636a9e
--- /dev/null
+++ b/actionpack/test/controller/http_digest_authentication_test.rb
@@ -0,0 +1,73 @@
+require 'abstract_unit'
+
+class HttpDigestAuthenticationTest < Test::Unit::TestCase
+  include ActionController::HttpAuthentication::Digest
+  
+  class DummyController
+    attr_accessor :headers, :renders, :request, :response
+
+    def initialize
+      @headers, @renders = {}, []
+      @request = ActionController::TestRequest.new
+      @response = ActionController::TestResponse.new
+      request.session.session_id = "test_session"
+    end
+    
+    def render(options)
+      self.renderers << options
+    end
+  end
+  
+  def setup
+    @controller = DummyController.new
+    @credentials = {
+      :username => "dhh",
+      :realm    => "testrealm@host.com",
+      :nonce    => ActionController::HttpAuthentication::Digest.nonce(@controller.request),
+      :qop      => "auth",
+      :nc       => "00000001",
+      :cnonce   => "0a4f113b",
+      :opaque   => ActionController::HttpAuthentication::Digest.opaque(@controller.request),
+      :uri      => "http://test.host/"
+    }
+    @encoded_credentials = ActionController::HttpAuthentication::Digest.encode_credentials("GET", @credentials, "secret")
+  end
+
+  def test_decode_credentials
+    set_headers
+    assert_equal @credentials, decode_credentials(@controller.request) 
+  end 
+    
+  def test_nonce_format
+    assert_nothing_thrown do
+      validate_nonce(@controller.request, nonce(@controller.request))
+    end
+  end
+  
+  def test_authenticate_should_raise_for_nil_password
+    set_headers ActionController::HttpAuthentication::Digest.encode_credentials(:get, @credentials, nil)
+    assert_raise ActionController::HttpAuthentication::Error do
+      authenticate(@controller, @credentials[:realm]) { |user| user == "dhh" && "secret" }
+    end
+  end 
+  
+  def test_authenticate_should_raise_for_incorrect_password 
+    set_headers
+    assert_raise ActionController::HttpAuthentication::Error do
+      authenticate(@controller, @credentials[:realm]) { |user| user == "dhh" && "bad password" }
+    end
+  end 
+ 
+  def test_authenticate_should_not_raise_for_correct_password 
+    set_headers
+    assert_nothing_thrown do
+      authenticate(@controller, @credentials[:realm]) { |user| user == "dhh" && "secret" }
+    end
+  end 
+
+  private
+    def set_headers(value = @encoded_credentials, name = 'HTTP_AUTHORIZATION', method = "GET")
+      @controller.request.env[name] = value
+      @controller.request.env["REQUEST_METHOD"] = method
+    end
+end
diff --git a/actionpack/test/controller/integration_test.rb b/actionpack/test/controller/integration_test.rb
index c28050fe0d..53cebf768e 100644
--- a/actionpack/test/controller/integration_test.rb
+++ b/actionpack/test/controller/integration_test.rb
@@ -8,7 +8,25 @@ class SessionTest < Test::Unit::TestCase
   }
 
   def setup
+    @credentials = {
+      :username => "username",
+      :realm    => "MyApp",
+      :nonce    => ActionController::HttpAuthentication::Digest.nonce("session_id"),
+      :qop      => "auth",
+      :nc       => "00000001",
+      :cnonce   => "0a4f113b",
+      :opaque   => ActionController::HttpAuthentication::Digest.opaque("session_id"),
+      :uri      => "/index"
+    }
+
     @session = ActionController::Integration::Session.new(StubApp)
+    @session.nonce = @credentials[:nonce]
+    @session.opaque = @credentials[:opaque]
+    @session.realm = @credentials[:realm]
+  end
+
+  def encoded_credentials(method)
+    ActionController::HttpAuthentication::Digest.encode_credentials(method, @credentials, "password")
   end
 
   def test_https_bang_works_and_sets_truth_by_default
@@ -132,6 +150,76 @@ class SessionTest < Test::Unit::TestCase
     @session.head(path,params,headers)
   end
 
+  def test_get_with_basic 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=\n")  
+    @session.expects(:process).with(:get,path,params,expected_headers) 
+    @session.get_with_basic(path,params,headers,'username','password') 
+  end 
+ 
+  def test_post_with_basic 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=\n")  
+    @session.expects(:process).with(:post,path,params,expected_headers) 
+    @session.post_with_basic(path,params,headers,'username','password') 
+  end 
+ 
+  def test_put_with_basic 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=\n")  
+    @session.expects(:process).with(:put,path,params,expected_headers) 
+    @session.put_with_basic(path,params,headers,'username','password') 
+  end 
+ 
+  def test_delete_with_basic 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=\n")  
+    @session.expects(:process).with(:delete,path,params,expected_headers) 
+    @session.delete_with_basic(path,params,headers,'username','password') 
+  end 
+ 
+  def test_head_with_basic 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=\n")  
+    @session.expects(:process).with(:head,path,params,expected_headers) 
+    @session.head_with_basic(path,params,headers,'username','password') 
+  end 
+ 
+  def test_get_with_digest 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => encoded_credentials(:get))
+    @session.expects(:process).with(:get,path,params,expected_headers) 
+    @session.get_with_digest(path,params,headers,'username','password') 
+  end 
+ 
+  def test_post_with_digest 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => encoded_credentials(:post))
+    @session.expects(:process).with(:post,path,params,expected_headers) 
+    @session.post_with_digest(path,params,headers,'username','password') 
+  end 
+ 
+  def test_put_with_digest 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => encoded_credentials(:put)) 
+    @session.expects(:process).with(:put,path,params,expected_headers) 
+    @session.put_with_digest(path,params,headers,'username','password') 
+  end 
+ 
+  def test_delete_with_digest 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => encoded_credentials(:delete))
+    @session.expects(:process).with(:delete,path,params,expected_headers) 
+    @session.delete_with_digest(path,params,headers,'username','password') 
+  end 
+ 
+  def test_head_with_digest 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => encoded_credentials(:head)) 
+    @session.expects(:process).with(:head,path,params,expected_headers) 
+    @session.head_with_digest(path,params,headers,'username','password') 
+  end 
+
   def test_xml_http_request_get
     path = "/index"; params = "blah"; headers = {:location => 'blah'}
     headers_after_xhr = headers.merge(
diff --git a/actionpack/test/controller/request_test.rb b/actionpack/test/controller/request_test.rb
index 349cea268f..c93d3152b8 100644
--- a/actionpack/test/controller/request_test.rb
+++ b/actionpack/test/controller/request_test.rb
@@ -441,6 +441,7 @@ class UrlEncodedRequestParameterParsingTest < ActiveSupport::TestCase
   def test_deep_query_string_with_array_of_hash
     assert_equal({'x' => {'y' => [{'z' => '10'}]}}, ActionController::RequestParser.parse_query_parameters('x[y][][z]=10'))
     assert_equal({'x' => {'y' => [{'z' => '10', 'w' => '10'}]}}, ActionController::RequestParser.parse_query_parameters('x[y][][z]=10&x[y][][w]=10'))
+    assert_equal({'x' => {'y' => [{'z' => '10', 'v' => {'w' => '10'}}]}}, ActionController::RequestParser.parse_query_parameters('x[y][][z]=10&x[y][][v][w]=10'))
   end
 
   def test_deep_query_string_with_array_of_hashes_with_one_pair
diff --git a/actionpack/test/controller/rescue_test.rb b/actionpack/test/controller/rescue_test.rb
index 63f9827f4a..d45ba3c3a1 100644
--- a/actionpack/test/controller/rescue_test.rb
+++ b/actionpack/test/controller/rescue_test.rb
@@ -67,6 +67,11 @@ class RescueController < ActionController::Base
     render :text => 'no way'
   end
 
+  before_filter(:only => :before_filter_raises) { raise 'umm nice' }
+
+  def before_filter_raises
+  end
+
   def raises
     render :text => 'already rendered'
     raise "don't panic!"
@@ -154,6 +159,16 @@ class RescueControllerTest < ActionController::TestCase
     end
   end
 
+  def test_rescue_exceptions_raised_by_filters
+    with_rails_root FIXTURE_PUBLIC do
+      with_all_requests_local false do
+        get :before_filter_raises
+      end
+    end
+
+    assert_response :internal_server_error
+  end
+
   def test_rescue_action_locally_if_all_requests_local
     @controller.expects(:local_request?).never
     @controller.expects(:rescue_action_locally).with(@exception)
@@ -367,7 +382,11 @@ class RescueControllerTest < ActionController::TestCase
   end
 
   def test_rescue_dispatcher_exceptions
-    RescueController.process_with_exception(@request, @response, ActionController::RoutingError.new("Route not found"))
+    env = @request.env
+    env["actioncontroller.rescue.request"] = @request
+    env["actioncontroller.rescue.response"] = @response
+
+    RescueController.call_with_exception(env, ActionController::RoutingError.new("Route not found"))
     assert_equal "no way", @response.body
   end
 
diff --git a/actionpack/test/controller/routing_test.rb b/actionpack/test/controller/routing_test.rb
index d5b6bd6b2a..b981119e1e 100644
--- a/actionpack/test/controller/routing_test.rb
+++ b/actionpack/test/controller/routing_test.rb
@@ -706,7 +706,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       port_string = port == 80 ? '' : ":#{port}"
 
       protocol = options.delete(:protocol) || "http"
-      host     = options.delete(:host) || "named.route.test"
+      host     = options.delete(:host) || "test.host"
       anchor   = "##{options.delete(:anchor)}" if options.key?(:anchor)
 
       path = routes.generate(options)
@@ -715,27 +715,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     end
 
     def request
-      @request ||= MockRequest.new(:host => "named.route.test", :method => :get)
-    end
-  end
-
-  class MockRequest
-    attr_accessor :path, :path_parameters, :host, :subdomains, :domain, :method
-
-    def initialize(values={})
-      values.each { |key, value| send("#{key}=", value) }
-      if values[:host]
-        subdomain, self.domain = values[:host].split(/\./, 2)
-        self.subdomains = [subdomain]
-      end
-    end
-
-    def protocol
-      "http://"
-    end
-
-    def host_with_port
-      (subdomains * '.') + '.' +  domain
+      @request ||= ActionController::TestRequest.new
     end
   end
 
@@ -900,7 +880,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     def test_basic_named_route
       rs.add_named_route :home, '', :controller => 'content', :action => 'list'
       x = setup_for_named_route
-      assert_equal("http://named.route.test/",
+      assert_equal("http://test.host/",
                    x.send(:home_url))
     end
 
@@ -908,7 +888,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       rs.add_named_route :home, '', :controller => 'content', :action => 'list'
       x = setup_for_named_route
       ActionController::Base.relative_url_root = "/foo"
-      assert_equal("http://named.route.test/foo/",
+      assert_equal("http://test.host/foo/",
                    x.send(:home_url))
       assert_equal "/foo/", x.send(:home_path)
       ActionController::Base.relative_url_root = nil
@@ -917,14 +897,14 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     def test_named_route_with_option
       rs.add_named_route :page, 'page/:title', :controller => 'content', :action => 'show_page'
       x = setup_for_named_route
-      assert_equal("http://named.route.test/page/new%20stuff",
+      assert_equal("http://test.host/page/new%20stuff",
                    x.send(:page_url, :title => 'new stuff'))
     end
 
     def test_named_route_with_default
       rs.add_named_route :page, 'page/:title', :controller => 'content', :action => 'show_page', :title => 'AboutPage'
       x = setup_for_named_route
-      assert_equal("http://named.route.test/page/AboutRails",
+      assert_equal("http://test.host/page/AboutRails",
                    x.send(:page_url, :title => "AboutRails"))
 
     end
@@ -932,21 +912,21 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     def test_named_route_with_name_prefix
       rs.add_named_route :page, 'page', :controller => 'content', :action => 'show_page', :name_prefix => 'my_'
       x = setup_for_named_route
-      assert_equal("http://named.route.test/page",
+      assert_equal("http://test.host/page",
                    x.send(:my_page_url))
     end
 
     def test_named_route_with_path_prefix
       rs.add_named_route :page, 'page', :controller => 'content', :action => 'show_page', :path_prefix => 'my'
       x = setup_for_named_route
-      assert_equal("http://named.route.test/my/page",
+      assert_equal("http://test.host/my/page",
                    x.send(:page_url))
     end
 
     def test_named_route_with_nested_controller
       rs.add_named_route :users, 'admin/user', :controller => 'admin/user', :action => 'index'
       x = setup_for_named_route
-      assert_equal("http://named.route.test/admin/user",
+      assert_equal("http://test.host/admin/user",
                    x.send(:users_url))
     end
 
@@ -985,7 +965,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
         map.root :controller => "hello"
       end
       x = setup_for_named_route
-      assert_equal("http://named.route.test/", x.send(:root_url))
+      assert_equal("http://test.host/", x.send(:root_url))
       assert_equal("/", x.send(:root_path))
     end
 
@@ -1001,7 +981,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       #   x.send(:article_url, :title => 'hi')
       # )
       assert_equal(
-        "http://named.route.test/page/2005/6/10/hi",
+        "http://test.host/page/2005/6/10/hi",
         x.send(:article_url, :title => 'hi', :day => 10, :year => 2005, :month => 6)
       )
     end
@@ -1202,7 +1182,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       assert_equal '/test', rs.generate(:controller => 'post', :action => 'show', :year => nil)
 
       x = setup_for_named_route
-      assert_equal("http://named.route.test/test",
+      assert_equal("http://test.host/test",
                    x.send(:blog_url))
     end
 
@@ -1249,7 +1229,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       assert_equal '/', rs.generate(:controller => 'content')
 
       x = setup_for_named_route
-      assert_equal("http://named.route.test/",
+      assert_equal("http://test.host/",
                    x.send(:home_url))
     end
 
@@ -1591,7 +1571,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     end
 
     def request
-      @request ||= MockRequest.new(:host => "named.routes.test", :method => :get)
+      @request ||= ActionController::TestRequest.new
     end
 
     def test_generate_extras
@@ -1692,13 +1672,13 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     def test_named_route_url_method
       controller = setup_named_route_test
 
-      assert_equal "http://named.route.test/people/5", controller.send(:show_url, :id => 5)
+      assert_equal "http://test.host/people/5", controller.send(:show_url, :id => 5)
       assert_equal "/people/5", controller.send(:show_path, :id => 5)
 
-      assert_equal "http://named.route.test/people", controller.send(:index_url)
+      assert_equal "http://test.host/people", controller.send(:index_url)
       assert_equal "/people", controller.send(:index_path)
 
-      assert_equal "http://named.route.test/admin/users", controller.send(:users_url)
+      assert_equal "http://test.host/admin/users", controller.send(:users_url)
       assert_equal '/admin/users', controller.send(:users_path)
       assert_equal '/admin/users', set.generate(controller.send(:hash_for_users_url), {:controller => 'users', :action => 'index'})
     end
@@ -1706,28 +1686,28 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     def test_named_route_url_method_with_anchor
       controller = setup_named_route_test
 
-      assert_equal "http://named.route.test/people/5#location", controller.send(:show_url, :id => 5, :anchor => 'location')
+      assert_equal "http://test.host/people/5#location", controller.send(:show_url, :id => 5, :anchor => 'location')
       assert_equal "/people/5#location", controller.send(:show_path, :id => 5, :anchor => 'location')
 
-      assert_equal "http://named.route.test/people#location", controller.send(:index_url, :anchor => 'location')
+      assert_equal "http://test.host/people#location", controller.send(:index_url, :anchor => 'location')
       assert_equal "/people#location", controller.send(:index_path, :anchor => 'location')
 
-      assert_equal "http://named.route.test/admin/users#location", controller.send(:users_url, :anchor => 'location')
+      assert_equal "http://test.host/admin/users#location", controller.send(:users_url, :anchor => 'location')
       assert_equal '/admin/users#location', controller.send(:users_path, :anchor => 'location')
 
-      assert_equal "http://named.route.test/people/go/7/hello/joe/5#location",
+      assert_equal "http://test.host/people/go/7/hello/joe/5#location",
         controller.send(:multi_url, 7, "hello", 5, :anchor => 'location')
 
-      assert_equal "http://named.route.test/people/go/7/hello/joe/5?baz=bar#location",
+      assert_equal "http://test.host/people/go/7/hello/joe/5?baz=bar#location",
         controller.send(:multi_url, 7, "hello", 5, :baz => "bar", :anchor => 'location')
 
-      assert_equal "http://named.route.test/people?baz=bar#location",
+      assert_equal "http://test.host/people?baz=bar#location",
         controller.send(:index_url, :baz => "bar", :anchor => 'location')
     end
 
     def test_named_route_url_method_with_port
       controller = setup_named_route_test
-      assert_equal "http://named.route.test:8080/people/5", controller.send(:show_url, 5, :port=>8080)
+      assert_equal "http://test.host:8080/people/5", controller.send(:show_url, 5, :port=>8080)
     end
 
     def test_named_route_url_method_with_host
@@ -1737,30 +1717,30 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
 
     def test_named_route_url_method_with_protocol
       controller = setup_named_route_test
-      assert_equal "https://named.route.test/people/5", controller.send(:show_url, 5, :protocol => "https")
+      assert_equal "https://test.host/people/5", controller.send(:show_url, 5, :protocol => "https")
     end
 
     def test_named_route_url_method_with_ordered_parameters
       controller = setup_named_route_test
-      assert_equal "http://named.route.test/people/go/7/hello/joe/5",
+      assert_equal "http://test.host/people/go/7/hello/joe/5",
         controller.send(:multi_url, 7, "hello", 5)
     end
 
     def test_named_route_url_method_with_ordered_parameters_and_hash
       controller = setup_named_route_test
-      assert_equal "http://named.route.test/people/go/7/hello/joe/5?baz=bar",
+      assert_equal "http://test.host/people/go/7/hello/joe/5?baz=bar",
         controller.send(:multi_url, 7, "hello", 5, :baz => "bar")
     end
 
     def test_named_route_url_method_with_ordered_parameters_and_empty_hash
       controller = setup_named_route_test
-      assert_equal "http://named.route.test/people/go/7/hello/joe/5",
+      assert_equal "http://test.host/people/go/7/hello/joe/5",
         controller.send(:multi_url, 7, "hello", 5, {})
     end
 
     def test_named_route_url_method_with_no_positional_arguments
       controller = setup_named_route_test
-      assert_equal "http://named.route.test/people?baz=bar",
+      assert_equal "http://test.host/people?baz=bar",
         controller.send(:index_url, :baz => "bar")
     end
 
@@ -1896,49 +1876,54 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/people"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("index", request.path_parameters[:action])
+      request.recycle!
 
-      request.method = :post
+      request.env["REQUEST_METHOD"] = "POST"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("create", request.path_parameters[:action])
+      request.recycle!
 
-      request.method = :put
+      request.env["REQUEST_METHOD"] = "PUT"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("update", request.path_parameters[:action])
+      request.recycle!
 
-      begin
-        request.method = :bacon
+      assert_raises(ActionController::UnknownHttpMethod) {
+        request.env["REQUEST_METHOD"] = "BACON"
         set.recognize(request)
-        flunk 'Should have raised NotImplemented'
-      rescue ActionController::NotImplemented => e
-        assert_equal [:get, :post, :put, :delete], e.allowed_methods
-      end
+      }
+      request.recycle!
 
       request.path = "/people/5"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("show", request.path_parameters[:action])
       assert_equal("5", request.path_parameters[:id])
+      request.recycle!
 
-      request.method = :put
+      request.env["REQUEST_METHOD"] = "PUT"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("update", request.path_parameters[:action])
       assert_equal("5", request.path_parameters[:id])
+      request.recycle!
 
-      request.method = :delete
+      request.env["REQUEST_METHOD"] = "DELETE"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("destroy", request.path_parameters[:action])
       assert_equal("5", request.path_parameters[:id])
+      request.recycle!
 
       begin
-        request.method = :post
+        request.env["REQUEST_METHOD"] = "POST"
         set.recognize(request)
         flunk 'Should have raised MethodNotAllowed'
       rescue ActionController::MethodNotAllowed => e
         assert_equal [:get, :put, :delete], e.allowed_methods
       end
+      request.recycle!
 
     ensure
       Object.send(:remove_const, :PeopleController)
@@ -1954,13 +1939,13 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/people"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("people", request.path_parameters[:controller])
       assert_equal("index", request.path_parameters[:action])
 
       request.path = "/"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("people", request.path_parameters[:controller])
       assert_equal("index", request.path_parameters[:action])
@@ -1978,7 +1963,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/articles/2005/11/05/a-very-interesting-article"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("permalink", request.path_parameters[:action])
       assert_equal("2005", request.path_parameters[:year])
@@ -2015,17 +2000,19 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/people/5"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("show", request.path_parameters[:action])
       assert_equal("5", request.path_parameters[:id])
+      request.recycle!
 
-      request.method = :put
+      request.env["REQUEST_METHOD"] = "PUT"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("update", request.path_parameters[:action])
+      request.recycle!
 
       request.path = "/people/5.png"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("show", request.path_parameters[:action])
       assert_equal("5", request.path_parameters[:id])
@@ -2050,7 +2037,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       set.draw { |map| map.root :controller => "people" }
 
       request.path = ""
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("people", request.path_parameters[:controller])
       assert_equal("index", request.path_parameters[:action])
@@ -2070,7 +2057,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/api/inventory"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("api/products", request.path_parameters[:controller])
       assert_equal("inventory", request.path_parameters[:action])
@@ -2090,7 +2077,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/api"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("api/products", request.path_parameters[:controller])
       assert_equal("index", request.path_parameters[:action])
@@ -2110,7 +2097,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/prefix/inventory"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("api/products", request.path_parameters[:controller])
       assert_equal("inventory", request.path_parameters[:action])
@@ -2246,7 +2233,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/projects/1/milestones"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("milestones", request.path_parameters[:controller])
       assert_equal("index", request.path_parameters[:action])
diff --git a/actionpack/test/template/compiled_templates_test.rb b/actionpack/test/template/compiled_templates_test.rb
index a68b09bb45..caea1bd643 100644
--- a/actionpack/test/template/compiled_templates_test.rb
+++ b/actionpack/test/template/compiled_templates_test.rb
@@ -31,7 +31,7 @@ uses_mocha 'TestTemplateRecompilation' do
     end
 
     def test_compiled_template_will_always_be_recompiled_when_template_is_not_cached
-      ActionView::Template.any_instance.expects(:loaded?).times(3).returns(false)
+      ActionView::Template.any_instance.expects(:recompile?).times(3).returns(true)
       assert_equal 0, @compiled_templates.instance_methods.size
       assert_equal "Hello world!", render(:file => "#{FIXTURE_LOAD_PATH}/test/hello_world.erb")
       ActionView::Template.any_instance.expects(:compile!).times(3)
@@ -62,13 +62,14 @@ uses_mocha 'TestTemplateRecompilation' do
 
       def render_with_cache(*args)
         view_paths = ActionController::Base.view_paths
-        assert view_paths.first.loaded?
+        assert_equal ActionView::Template::EagerPath, view_paths.first.class
         ActionView::Base.new(view_paths, {}).render(*args)
       end
 
       def render_without_cache(*args)
-        view_paths = ActionView::Base.process_view_paths(FIXTURE_LOAD_PATH)
-        assert !view_paths.first.loaded?
+        path = ActionView::Template::Path.new(FIXTURE_LOAD_PATH)
+        view_paths = ActionView::Base.process_view_paths(path)
+        assert_equal ActionView::Template::Path, view_paths.first.class
         ActionView::Base.new(view_paths, {}).render(*args)
       end
 
diff --git a/actionpack/test/template/render_test.rb b/actionpack/test/template/render_test.rb
index 0387a11de2..4bd897efeb 100644
--- a/actionpack/test/template/render_test.rb
+++ b/actionpack/test/template/render_test.rb
@@ -197,7 +197,7 @@ class CachedViewRenderTest < Test::Unit::TestCase
   # Ensure view path cache is primed
   def setup
     view_paths = ActionController::Base.view_paths
-    assert view_paths.first.loaded?
+    assert_equal ActionView::Template::EagerPath, view_paths.first.class
     setup_view(view_paths)
   end
 end
@@ -208,8 +208,9 @@ class LazyViewRenderTest < Test::Unit::TestCase
   # Test the same thing as above, but make sure the view path
   # is not eager loaded
   def setup
-    view_paths = ActionView::Base.process_view_paths(FIXTURE_LOAD_PATH)
-    assert !view_paths.first.loaded?
+    path = ActionView::Template::Path.new(FIXTURE_LOAD_PATH)
+    view_paths = ActionView::Base.process_view_paths(path)
+    assert_equal ActionView::Template::Path, view_paths.first.class
     setup_view(view_paths)
   end
 end