Deprecate template, session, assigns, and layout accessors on response object. Instead access them through the controller instance. This mainly affects functional test assertions.

15 files changed, 195 insertions, 142 deletions

diff --git a/actionpack/lib/action_controller/base/base.rb b/actionpack/lib/action_controller/base/base.rb
index 2063df54b4..14c4339c94 100644
--- a/actionpack/lib/action_controller/base/base.rb
+++ b/actionpack/lib/action_controller/base/base.rb
@@ -367,6 +367,8 @@ module ActionController #:nodoc:
     # Returns the name of the action this controller is processing.
     attr_accessor :action_name
 
+    attr_reader :template
+
     class << self
       def call(env)
         # HACK: For global rescue to have access to the original request and response
@@ -816,7 +818,7 @@ module ActionController #:nodoc:
 
       def initialize_template_class(response)
         @template = response.template = ActionView::Base.new(self.class.view_paths, {}, self, formats)
-        response.template.helpers.send :include, self.class.master_helper_module
+        @template.helpers.send :include, self.class.master_helper_module
         response.redirected_to = nil
         @performed_render = @performed_redirect = false
       end
diff --git a/actionpack/lib/action_controller/base/mime_responds.rb b/actionpack/lib/action_controller/base/mime_responds.rb
index bac225ab2a..1003e61a0b 100644
--- a/actionpack/lib/action_controller/base/mime_responds.rb
+++ b/actionpack/lib/action_controller/base/mime_responds.rb
@@ -127,7 +127,7 @@ module ActionController #:nodoc:
         @order << mime_type
 
         @responses[mime_type] ||= Proc.new do
-          @response.template.formats = [mime_type.to_sym]
+          @controller.template.formats = [mime_type.to_sym]
           @response.content_type = mime_type.to_s
           block_given? ? block.call : @controller.send(:render, :action => @controller.action_name)
         end
diff --git a/actionpack/lib/action_controller/caching/actions.rb b/actionpack/lib/action_controller/caching/actions.rb
index b99feddf77..d95a346862 100644
--- a/actionpack/lib/action_controller/caching/actions.rb
+++ b/actionpack/lib/action_controller/caching/actions.rb
@@ -121,7 +121,7 @@ module ActionController #:nodoc:
           end
 
           def content_for_layout(controller)
-            controller.response.layout && controller.response.template.instance_variable_get('@cached_content_for_layout')
+            controller.template.layout && controller.template.instance_variable_get('@cached_content_for_layout')
           end
       end
 
diff --git a/actionpack/lib/action_controller/testing/assertions/response.rb b/actionpack/lib/action_controller/testing/assertions/response.rb
index a4a3dcdec8..684fe1ffe0 100644
--- a/actionpack/lib/action_controller/testing/assertions/response.rb
+++ b/actionpack/lib/action_controller/testing/assertions/response.rb
@@ -33,7 +33,7 @@ module ActionController
             assert_block("") { true } # to count the assertion
           else
             if @controller && @response.error?
-              exception = @controller.response.template.instance_variable_get(:@exception)
+              exception = @controller.template.instance_variable_get(:@exception)
               exception_message = exception && exception.message
               assert_block(build_message(message, "Expected response to be a <?>, but was <?>\n<?>", type, @response.response_code, exception_message.to_s)) { false }
             else
@@ -98,20 +98,20 @@ module ActionController
         clean_backtrace do
           case options
            when NilClass, String
-            rendered = (@controller.response.rendered[:template] || []).map { |t| t.identifier }
+            rendered = (@controller.template.rendered[:template] || []).map { |t| t.identifier }
             msg = build_message(message,
                     "expecting <?> but rendering with <?>",
                     options, rendered.join(', '))
             assert_block(msg) do
               if options.nil?
-                @controller.response.rendered[:template].blank?
+                @controller.template.rendered[:template].blank?
               else
                 rendered.any? { |t| t.match(options) }
               end
             end
           when Hash
             if expected_partial = options[:partial]
-              partials = @controller.response.rendered[:partials]
+              partials = @controller.template.rendered[:partials]
               if expected_count = options[:count]
                 found = partials.detect { |p, _| p.identifier.match(expected_partial) }
                 actual_count = found.nil? ? 0 : found.second
@@ -126,7 +126,7 @@ module ActionController
                 assert(partials.keys.any? { |p| p.identifier.match(expected_partial) }, msg)
               end
             else
-              assert @controller.response.rendered[:partials].empty?,
+              assert @controller.template.rendered[:partials].empty?,
                 "Expected no partials to be rendered"
             end
           end
diff --git a/actionpack/lib/action_controller/testing/process.rb b/actionpack/lib/action_controller/testing/process.rb
index d073d06b19..16a8f66bc4 100644
--- a/actionpack/lib/action_controller/testing/process.rb
+++ b/actionpack/lib/action_controller/testing/process.rb
@@ -160,7 +160,8 @@ module ActionController #:nodoc:
     # Returns the template of the file which was used to
     # render this response (or nil)
     def rendered
-      template.instance_variable_get(:@_rendered)
+      ActiveSupport::Deprecation.warn("response.rendered has been deprecated. Use tempate.rendered instead", caller)
+      @template.instance_variable_get(:@_rendered)
     end
 
     # A shortcut to the flash. Returns an empty hash if no session flash exists.
@@ -190,11 +191,13 @@ module ActionController #:nodoc:
 
     # A shortcut to the template.assigns
     def template_objects
-      template.assigns || {}
+      ActiveSupport::Deprecation.warn("response.template_objects has been deprecated. Use tempate.assigns instead", caller)
+      @template.assigns || {}
     end
 
     # Does the specified template object exist?
     def has_template_object?(name=nil)
+      ActiveSupport::Deprecation.warn("response.has_template_object? has been deprecated. Use tempate.assigns[name].nil? instead", caller)
       !template_objects[name].nil?
     end
 
@@ -317,9 +320,9 @@ module ActionController #:nodoc:
 
     def assigns(key = nil)
       if key.nil?
-        @response.template.assigns
+        @controller.template.assigns
       else
-        @response.template.assigns[key.to_s]
+        @controller.template.assigns[key.to_s]
       end
     end
 
@@ -431,7 +434,7 @@ module ActionController #:nodoc:
         (instance_variable_names - self.class.protected_instance_variables).each do |var|
           name, value = var[1..-1], instance_variable_get(var)
           @assigns[name] = value
-          response.template.assigns[name] = value if response
+          @template.assigns[name] = value if response
         end
       end
   end
diff --git a/actionpack/lib/action_dispatch/http/response.rb b/actionpack/lib/action_dispatch/http/response.rb
index f570b8e8ed..d104dcb8a0 100644
--- a/actionpack/lib/action_dispatch/http/response.rb
+++ b/actionpack/lib/action_dispatch/http/response.rb
@@ -34,20 +34,30 @@ module ActionDispatch # :nodoc:
     DEFAULT_HEADERS = { "Cache-Control" => "no-cache" }
     attr_accessor :request
 
-    attr_accessor :template, :layout
     attr_accessor :redirected_to, :redirected_to_method_params
 
     attr_writer :header
     alias_method :headers=, :header=
 
+    def template
+      ActiveSupport::Deprecation.warn("response.template has been deprecated. Use controller.template instead", caller)
+      @template
+    end
+    attr_writer :template
+
     def session
       ActiveSupport::Deprecation.warn("response.session has been deprecated. Use request.session instead", caller)
-      request.session
+      @request.session
     end
 
     def assigns
       ActiveSupport::Deprecation.warn("response.assigns has been deprecated. Use controller.assigns instead", caller)
-      template.assigns
+      @template.controller.assigns
+    end
+
+    def layout
+      ActiveSupport::Deprecation.warn("response.layout has been deprecated. Use template.layout instead", caller)
+      @template.layout
     end
 
     delegate :default_charset, :to => 'ActionController::Base'
diff --git a/actionpack/lib/action_view/base.rb b/actionpack/lib/action_view/base.rb
index d087395361..44bd401631 100644
--- a/actionpack/lib/action_view/base.rb
+++ b/actionpack/lib/action_view/base.rb
@@ -191,7 +191,7 @@ module ActionView #:nodoc:
       ActionController::Base.allow_concurrency || (cache_template_loading.nil? ? !ActiveSupport::Dependencies.load? : cache_template_loading)
     end
 
-    attr_internal :request
+    attr_internal :request, :layout
 
     delegate :controller_path, :to => :controller, :allow_nil => true
 
diff --git a/actionpack/lib/action_view/render/rendering.rb b/actionpack/lib/action_view/render/rendering.rb
index f174053b86..6e368f27eb 100644
--- a/actionpack/lib/action_view/render/rendering.rb
+++ b/actionpack/lib/action_view/render/rendering.rb
@@ -46,7 +46,7 @@ module ActionView
       locals ||= {}
 
       if controller && layout
-        response.layout = layout.identifier if controller.respond_to?(:response)
+        @_layout = layout.identifier
         logger.info("Rendering template within #{layout.identifier}") if logger
       end
   
diff --git a/actionpack/lib/action_view/test_case.rb b/actionpack/lib/action_view/test_case.rb
index dddd671812..50bed67f7d 100644
--- a/actionpack/lib/action_view/test_case.rb
+++ b/actionpack/lib/action_view/test_case.rb
@@ -7,7 +7,8 @@ module ActionView
       @_rendered = { :template => nil, :partials => Hash.new(0) }
       initialize_without_template_tracking(*args)
     end
-    
+
+    attr_internal :rendered
     alias_method :_render_template_without_template_tracking, :_render_template
     def _render_template(template, local_assigns = {})
       if template.respond_to?(:identifier)
@@ -16,7 +17,7 @@ module ActionView
         @_rendered[:template] << template
       end
       _render_template_without_template_tracking(template, local_assigns)
-    end    
+    end
   end
 
   class TestCase < ActiveSupport::TestCase
diff --git a/actionpack/test/controller/action_pack_assertions_test.rb b/actionpack/test/controller/action_pack_assertions_test.rb
index f091f9b87c..dd59999a0c 100644
--- a/actionpack/test/controller/action_pack_assertions_test.rb
+++ b/actionpack/test/controller/action_pack_assertions_test.rb
@@ -292,14 +292,14 @@ class ActionPackAssertionsControllerTest < ActionController::TestCase
   # make sure that the template objects exist
   def test_template_objects_alive
     process :assign_this
-    assert !@response.has_template_object?('hi')
-    assert @response.has_template_object?('howdy')
+    assert !@controller.template.assigns['hi']
+    assert @controller.template.assigns['howdy']
   end
 
   # make sure we don't have template objects when we shouldn't
   def test_template_object_missing
     process :nothing
-    assert_nil @response.template_objects['howdy']
+    assert_nil @controller.template.assigns['howdy']
   end
 
   # check the empty flashing
@@ -328,11 +328,11 @@ class ActionPackAssertionsControllerTest < ActionController::TestCase
   # check if we were rendered by a file-based template?
   def test_rendered_action
     process :nothing
-    assert_nil @response.rendered[:template]
+    assert_nil @controller.template.rendered[:template]
 
     process :hello_world
-    assert @response.rendered[:template]
-    assert 'hello_world', @response.rendered[:template].to_s
+    assert @controller.template.rendered[:template]
+    assert 'hello_world', @controller.template.rendered[:template].to_s
   end
 
   # check the redirection location
diff --git a/actionpack/test/controller/filters_test.rb b/actionpack/test/controller/filters_test.rb
index e83fde2349..aca7a821c8 100644
--- a/actionpack/test/controller/filters_test.rb
+++ b/actionpack/test/controller/filters_test.rb
@@ -165,11 +165,11 @@ class FilterTest < Test::Unit::TestCase
     def index
       render :text => 'ok'
     end
-    
+
     def public
     end
   end
-  
+
   class SkippingAndReorderingController < TestController
     skip_before_filter :ensure_login
     before_filter :find_record
@@ -450,7 +450,8 @@ class FilterTest < Test::Unit::TestCase
 
   def test_empty_filter_chain
     assert_equal 0, EmptyFilterChainController.filter_chain.size
-    assert test_process(EmptyFilterChainController).template.assigns['action_executed']
+    test_process(EmptyFilterChainController)
+    assert @controller.template.assigns['action_executed']
   end
 
   def test_added_filter_to_inheritance_graph
@@ -466,88 +467,109 @@ class FilterTest < Test::Unit::TestCase
   end
 
   def test_running_filters
-    assert_equal %w( wonderful_life ensure_login ), test_process(PrependingController).template.assigns["ran_filter"]
+    test_process(PrependingController)
+    assert_equal %w( wonderful_life ensure_login ), @controller.template.assigns["ran_filter"]
   end
 
   def test_running_filters_with_proc
-    assert test_process(ProcController).template.assigns["ran_proc_filter"]
+    test_process(ProcController)
+    assert @controller.template.assigns["ran_proc_filter"]
   end
 
   def test_running_filters_with_implicit_proc
-    assert test_process(ImplicitProcController).template.assigns["ran_proc_filter"]
+    test_process(ImplicitProcController)
+    assert @controller.template.assigns["ran_proc_filter"]
   end
 
   def test_running_filters_with_class
-    assert test_process(AuditController).template.assigns["was_audited"]
+    test_process(AuditController)
+    assert @controller.template.assigns["was_audited"]
   end
 
   def test_running_anomolous_yet_valid_condition_filters
-    response = test_process(AnomolousYetValidConditionController)
-    assert_equal %w( ensure_login ), response.template.assigns["ran_filter"]
-    assert response.template.assigns["ran_class_filter"]
-    assert response.template.assigns["ran_proc_filter1"]
-    assert response.template.assigns["ran_proc_filter2"]
+    test_process(AnomolousYetValidConditionController)
+    assert_equal %w( ensure_login ), @controller.template.assigns["ran_filter"]
+    assert @controller.template.assigns["ran_class_filter"]
+    assert @controller.template.assigns["ran_proc_filter1"]
+    assert @controller.template.assigns["ran_proc_filter2"]
 
-    response = test_process(AnomolousYetValidConditionController, "show_without_filter")
-    assert_equal nil, response.template.assigns["ran_filter"]
-    assert !response.template.assigns["ran_class_filter"]
-    assert !response.template.assigns["ran_proc_filter1"]
-    assert !response.template.assigns["ran_proc_filter2"]
+    test_process(AnomolousYetValidConditionController, "show_without_filter")
+    assert_equal nil, @controller.template.assigns["ran_filter"]
+    assert !@controller.template.assigns["ran_class_filter"]
+    assert !@controller.template.assigns["ran_proc_filter1"]
+    assert !@controller.template.assigns["ran_proc_filter2"]
   end
 
   def test_running_conditional_options
-    response = test_process(ConditionalOptionsFilter)
-    assert_equal %w( ensure_login ), response.template.assigns["ran_filter"]
+    test_process(ConditionalOptionsFilter)
+    assert_equal %w( ensure_login ), @controller.template.assigns["ran_filter"]
   end
 
   def test_running_collection_condition_filters
-    assert_equal %w( ensure_login ), test_process(ConditionalCollectionFilterController).template.assigns["ran_filter"]
-    assert_equal nil, test_process(ConditionalCollectionFilterController, "show_without_filter").template.assigns["ran_filter"]
-    assert_equal nil, test_process(ConditionalCollectionFilterController, "another_action").template.assigns["ran_filter"]
+    test_process(ConditionalCollectionFilterController)
+    assert_equal %w( ensure_login ), @controller.template.assigns["ran_filter"]
+    test_process(ConditionalCollectionFilterController, "show_without_filter")
+    assert_equal nil, @controller.template.assigns["ran_filter"]
+    test_process(ConditionalCollectionFilterController, "another_action")
+    assert_equal nil, @controller.template.assigns["ran_filter"]
   end
 
   def test_running_only_condition_filters
-    assert_equal %w( ensure_login ), test_process(OnlyConditionSymController).template.assigns["ran_filter"]
-    assert_equal nil, test_process(OnlyConditionSymController, "show_without_filter").template.assigns["ran_filter"]
+    test_process(OnlyConditionSymController)
+    assert_equal %w( ensure_login ), @controller.template.assigns["ran_filter"]
+    test_process(OnlyConditionSymController, "show_without_filter")
+    assert_equal nil, @controller.template.assigns["ran_filter"]
 
-    assert test_process(OnlyConditionProcController).template.assigns["ran_proc_filter"]
-    assert !test_process(OnlyConditionProcController, "show_without_filter").template.assigns["ran_proc_filter"]
+    test_process(OnlyConditionProcController)
+    assert @controller.template.assigns["ran_proc_filter"]
+    test_process(OnlyConditionProcController, "show_without_filter")
+    assert !@controller.template.assigns["ran_proc_filter"]
 
-    assert test_process(OnlyConditionClassController).template.assigns["ran_class_filter"]
-    assert !test_process(OnlyConditionClassController, "show_without_filter").template.assigns["ran_class_filter"]
+    test_process(OnlyConditionClassController)
+    assert @controller.template.assigns["ran_class_filter"]
+    test_process(OnlyConditionClassController, "show_without_filter")
+    assert !@controller.template.assigns["ran_class_filter"]
   end
 
   def test_running_except_condition_filters
-    assert_equal %w( ensure_login ), test_process(ExceptConditionSymController).template.assigns["ran_filter"]
-    assert_equal nil, test_process(ExceptConditionSymController, "show_without_filter").template.assigns["ran_filter"]
+    test_process(ExceptConditionSymController)
+    assert_equal %w( ensure_login ), @controller.template.assigns["ran_filter"]
+    test_process(ExceptConditionSymController, "show_without_filter")
+    assert_equal nil, @controller.template.assigns["ran_filter"]
 
-    assert test_process(ExceptConditionProcController).template.assigns["ran_proc_filter"]
-    assert !test_process(ExceptConditionProcController, "show_without_filter").template.assigns["ran_proc_filter"]
+    test_process(ExceptConditionProcController)
+    assert @controller.template.assigns["ran_proc_filter"]
+    test_process(ExceptConditionProcController, "show_without_filter")
+    assert !@controller.template.assigns["ran_proc_filter"]
 
-    assert test_process(ExceptConditionClassController).template.assigns["ran_class_filter"]
-    assert !test_process(ExceptConditionClassController, "show_without_filter").template.assigns["ran_class_filter"]
+    test_process(ExceptConditionClassController)
+    assert @controller.template.assigns["ran_class_filter"]
+    test_process(ExceptConditionClassController, "show_without_filter")
+    assert !@controller.template.assigns["ran_class_filter"]
   end
 
   def test_running_before_and_after_condition_filters
-    assert_equal %w( ensure_login clean_up_tmp), test_process(BeforeAndAfterConditionController).template.assigns["ran_filter"]
-    assert_equal nil, test_process(BeforeAndAfterConditionController, "show_without_filter").template.assigns["ran_filter"]
+    test_process(BeforeAndAfterConditionController)
+    assert_equal %w( ensure_login clean_up_tmp), @controller.template.assigns["ran_filter"]
+    test_process(BeforeAndAfterConditionController, "show_without_filter")
+    assert_equal nil, @controller.template.assigns["ran_filter"]
   end
 
   def test_around_filter
-    controller = test_process(AroundFilterController)
-    assert controller.template.assigns["before_ran"]
-    assert controller.template.assigns["after_ran"]
+    test_process(AroundFilterController)
+    assert @controller.template.assigns["before_ran"]
+    assert @controller.template.assigns["after_ran"]
   end
 
   def test_before_after_class_filter
-    controller = test_process(BeforeAfterClassFilterController)
-    assert controller.template.assigns["before_ran"]
-    assert controller.template.assigns["after_ran"]
+    test_process(BeforeAfterClassFilterController)
+    assert @controller.template.assigns["before_ran"]
+    assert @controller.template.assigns["after_ran"]
   end
 
   def test_having_properties_in_around_filter
-    controller = test_process(AroundFilterController)
-    assert_equal "before and after", controller.template.assigns["execution_log"]
+    test_process(AroundFilterController)
+    assert_equal "before and after", @controller.template.assigns["execution_log"]
   end
 
   def test_prepending_and_appending_around_filter
@@ -560,7 +582,7 @@ class FilterTest < Test::Unit::TestCase
   def test_rendering_breaks_filtering_chain
     response = test_process(RenderingController)
     assert_equal "something else", response.body
-    assert !response.template.assigns["ran_action"]
+    assert !@controller.template.assigns["ran_action"]
   end
 
   def test_filters_with_mixed_specialization_run_in_order
@@ -586,40 +608,53 @@ class FilterTest < Test::Unit::TestCase
 
   def test_running_prepended_before_and_after_filter
     assert_equal 3, PrependingBeforeAndAfterController.filter_chain.length
-    response = test_process(PrependingBeforeAndAfterController)
-    assert_equal %w( before_all between_before_all_and_after_all after_all ), response.template.assigns["ran_filter"]
+    test_process(PrependingBeforeAndAfterController)
+    assert_equal %w( before_all between_before_all_and_after_all after_all ), @controller.template.assigns["ran_filter"]
   end
-  
+
   def test_skipping_and_limiting_controller
-    assert_equal %w( ensure_login ), test_process(SkippingAndLimitedController, "index").template.assigns["ran_filter"]
-    assert_nil test_process(SkippingAndLimitedController, "public").template.assigns["ran_filter"]
+    test_process(SkippingAndLimitedController, "index")
+    assert_equal %w( ensure_login ), @controller.template.assigns["ran_filter"]
+    test_process(SkippingAndLimitedController, "public")
+    assert_nil @controller.template.assigns["ran_filter"]
   end
 
   def test_skipping_and_reordering_controller
-    assert_equal %w( find_record ensure_login ), test_process(SkippingAndReorderingController, "index").template.assigns["ran_filter"]
+    test_process(SkippingAndReorderingController, "index")
+    assert_equal %w( find_record ensure_login ), @controller.template.assigns["ran_filter"]
   end
 
   def test_conditional_skipping_of_filters
-    assert_nil test_process(ConditionalSkippingController, "login").template.assigns["ran_filter"]
-    assert_equal %w( ensure_login find_user ), test_process(ConditionalSkippingController, "change_password").template.assigns["ran_filter"]
+    test_process(ConditionalSkippingController, "login")
+    assert_nil @controller.template.assigns["ran_filter"]
+    test_process(ConditionalSkippingController, "change_password")
+    assert_equal %w( ensure_login find_user ), @controller.template.assigns["ran_filter"]
 
-    assert_nil test_process(ConditionalSkippingController, "login").template.controller.instance_variable_get("@ran_after_filter")
-    assert_equal %w( clean_up ), test_process(ConditionalSkippingController, "change_password").template.controller.instance_variable_get("@ran_after_filter")
+    test_process(ConditionalSkippingController, "login")
+    assert_nil @controller.template.controller.instance_variable_get("@ran_after_filter")
+    test_process(ConditionalSkippingController, "change_password")
+    assert_equal %w( clean_up ), @controller.template.controller.instance_variable_get("@ran_after_filter")
   end
 
   def test_conditional_skipping_of_filters_when_parent_filter_is_also_conditional
-    assert_equal %w( conditional_in_parent conditional_in_parent ), test_process(ChildOfConditionalParentController).template.assigns['ran_filter']
-    assert_nil test_process(ChildOfConditionalParentController, 'another_action').template.assigns['ran_filter']
+    test_process(ChildOfConditionalParentController)
+    assert_equal %w( conditional_in_parent conditional_in_parent ), @controller.template.assigns['ran_filter']
+    test_process(ChildOfConditionalParentController, 'another_action')
+    assert_nil @controller.template.assigns['ran_filter']
   end
 
   def test_condition_skipping_of_filters_when_siblings_also_have_conditions
-    assert_equal %w( conditional_in_parent conditional_in_parent ), test_process(ChildOfConditionalParentController).template.assigns['ran_filter'], "1"
-    assert_equal nil, test_process(AnotherChildOfConditionalParentController).template.assigns['ran_filter']
-    assert_equal %w( conditional_in_parent conditional_in_parent ), test_process(ChildOfConditionalParentController).template.assigns['ran_filter']
+    test_process(ChildOfConditionalParentController)
+    assert_equal %w( conditional_in_parent conditional_in_parent ), @controller.template.assigns['ran_filter'], "1"
+    test_process(AnotherChildOfConditionalParentController)
+    assert_equal nil, @controller.template.assigns['ran_filter']
+    test_process(ChildOfConditionalParentController)
+    assert_equal %w( conditional_in_parent conditional_in_parent ), @controller.template.assigns['ran_filter']
   end
 
   def test_changing_the_requirements
-    assert_equal nil, test_process(ChangingTheRequirementsController, "go_wild").template.assigns['ran_filter']
+    test_process(ChangingTheRequirementsController, "go_wild")
+    assert_equal nil, @controller.template.assigns['ran_filter']
   end
 
   def test_a_rescuing_around_filter
@@ -638,7 +673,8 @@ class FilterTest < Test::Unit::TestCase
       request = ActionController::TestRequest.new
       request.action = action
       controller = controller.new if controller.is_a?(Class)
-      controller.process_with_test(request, ActionController::TestResponse.new)
+      @controller = controller
+      @controller.process_with_test(request, ActionController::TestResponse.new)
     end
 end
 
@@ -819,9 +855,9 @@ class YieldingAroundFiltersTest < Test::Unit::TestCase
   end
 
   def test_with_proc
-    controller = test_process(ControllerWithProcFilter,'no_raise')
-    assert controller.template.assigns['before']
-    assert controller.template.assigns['after']
+    test_process(ControllerWithProcFilter,'no_raise')
+    assert @controller.template.assigns['before']
+    assert @controller.template.assigns['after']
   end
 
   def test_nested_filters
@@ -841,13 +877,13 @@ class YieldingAroundFiltersTest < Test::Unit::TestCase
   end
 
   def test_filter_order_with_all_filter_types
-    controller = test_process(ControllerWithAllTypesOfFilters,'no_raise')
-    assert_equal 'before around (before yield) around_again (before yield) around_again (after yield) around (after yield) after',controller.template.assigns['ran_filter'].join(' ')
+    test_process(ControllerWithAllTypesOfFilters,'no_raise')
+    assert_equal 'before around (before yield) around_again (before yield) around_again (after yield) around (after yield) after', @controller.template.assigns['ran_filter'].join(' ')
   end
 
   def test_filter_order_with_skip_filter_method
-    controller = test_process(ControllerWithTwoLessFilters,'no_raise')
-    assert_equal 'before around (before yield) around (after yield)',controller.template.assigns['ran_filter'].join(' ')
+    test_process(ControllerWithTwoLessFilters,'no_raise')
+    assert_equal 'before around (before yield) around (after yield)', @controller.template.assigns['ran_filter'].join(' ')
   end
 
   def test_first_filter_in_multiple_before_filter_chain_halts
@@ -880,6 +916,7 @@ class YieldingAroundFiltersTest < Test::Unit::TestCase
       request = ActionController::TestRequest.new
       request.action = action
       controller = controller.new if controller.is_a?(Class)
-      controller.process_with_test(request, ActionController::TestResponse.new)
+      @controller = controller
+      @controller.process_with_test(request, ActionController::TestResponse.new)
     end
 end
diff --git a/actionpack/test/controller/flash_test.rb b/actionpack/test/controller/flash_test.rb
index d8a892811e..ef60cae0ff 100644
--- a/actionpack/test/controller/flash_test.rb
+++ b/actionpack/test/controller/flash_test.rb
@@ -79,64 +79,64 @@ class FlashTest < ActionController::TestCase
     get :set_flash
 
     get :use_flash
-    assert_equal "hello", @response.template.assigns["flash_copy"]["that"]
-    assert_equal "hello", @response.template.assigns["flashy"]
+    assert_equal "hello", @controller.template.assigns["flash_copy"]["that"]
+    assert_equal "hello", @controller.template.assigns["flashy"]
 
     get :use_flash
-    assert_nil @response.template.assigns["flash_copy"]["that"], "On second flash"
+    assert_nil @controller.template.assigns["flash_copy"]["that"], "On second flash"
   end
 
   def test_keep_flash
     get :set_flash
     
     get :use_flash_and_keep_it
-    assert_equal "hello", @response.template.assigns["flash_copy"]["that"]
-    assert_equal "hello", @response.template.assigns["flashy"]
+    assert_equal "hello", @controller.template.assigns["flash_copy"]["that"]
+    assert_equal "hello", @controller.template.assigns["flashy"]
 
     get :use_flash
-    assert_equal "hello", @response.template.assigns["flash_copy"]["that"], "On second flash"
+    assert_equal "hello", @controller.template.assigns["flash_copy"]["that"], "On second flash"
 
     get :use_flash
-    assert_nil @response.template.assigns["flash_copy"]["that"], "On third flash"
+    assert_nil @controller.template.assigns["flash_copy"]["that"], "On third flash"
   end
   
   def test_flash_now
     get :set_flash_now
-    assert_equal "hello", @response.template.assigns["flash_copy"]["that"]
-    assert_equal "bar"  , @response.template.assigns["flash_copy"]["foo"]
-    assert_equal "hello", @response.template.assigns["flashy"]
+    assert_equal "hello", @controller.template.assigns["flash_copy"]["that"]
+    assert_equal "bar"  , @controller.template.assigns["flash_copy"]["foo"]
+    assert_equal "hello", @controller.template.assigns["flashy"]
 
     get :attempt_to_use_flash_now
-    assert_nil @response.template.assigns["flash_copy"]["that"]
-    assert_nil @response.template.assigns["flash_copy"]["foo"]
-    assert_nil @response.template.assigns["flashy"]
+    assert_nil @controller.template.assigns["flash_copy"]["that"]
+    assert_nil @controller.template.assigns["flash_copy"]["foo"]
+    assert_nil @controller.template.assigns["flashy"]
   end 
   
   def test_update_flash
     get :set_flash
     get :use_flash_and_update_it
-    assert_equal "hello",       @response.template.assigns["flash_copy"]["that"]
-    assert_equal "hello again", @response.template.assigns["flash_copy"]["this"]
+    assert_equal "hello",       @controller.template.assigns["flash_copy"]["that"]
+    assert_equal "hello again", @controller.template.assigns["flash_copy"]["this"]
     get :use_flash
-    assert_nil                  @response.template.assigns["flash_copy"]["that"], "On second flash"
-    assert_equal "hello again", @response.template.assigns["flash_copy"]["this"], "On second flash"
+    assert_nil                  @controller.template.assigns["flash_copy"]["that"], "On second flash"
+    assert_equal "hello again", @controller.template.assigns["flash_copy"]["this"], "On second flash"
   end
   
   def test_flash_after_reset_session
     get :use_flash_after_reset_session
-    assert_equal "hello",    @response.template.assigns["flashy_that"]
-    assert_equal "good-bye", @response.template.assigns["flashy_this"]
-    assert_nil   @response.template.assigns["flashy_that_reset"]
+    assert_equal "hello",    @controller.template.assigns["flashy_that"]
+    assert_equal "good-bye", @controller.template.assigns["flashy_this"]
+    assert_nil   @controller.template.assigns["flashy_that_reset"]
   end 
 
   def test_sweep_after_halted_filter_chain
     get :std_action
-    assert_nil @response.template.assigns["flash_copy"]["foo"]
+    assert_nil @controller.template.assigns["flash_copy"]["foo"]
     get :filter_halting_action
-    assert_equal "bar", @response.template.assigns["flash_copy"]["foo"]
+    assert_equal "bar", @controller.template.assigns["flash_copy"]["foo"]
     get :std_action # follow redirection
-    assert_equal "bar", @response.template.assigns["flash_copy"]["foo"]
+    assert_equal "bar", @controller.template.assigns["flash_copy"]["foo"]
     get :std_action
-    assert_nil @response.template.assigns["flash_copy"]["foo"]
+    assert_nil @controller.template.assigns["flash_copy"]["foo"]
   end
 end
diff --git a/actionpack/test/controller/layout_test.rb b/actionpack/test/controller/layout_test.rb
index 11559b4071..da3f7b0cb8 100644
--- a/actionpack/test/controller/layout_test.rb
+++ b/actionpack/test/controller/layout_test.rb
@@ -57,7 +57,7 @@ class LayoutAutoDiscoveryTest < ActionController::TestCase
     @controller = ThirdPartyTemplateLibraryController.new
     get :hello
     assert @controller.active_layout(true).identifier.include?('layouts/third_party_template_library.mab')
-    assert @response.layout.include?('layouts/third_party_template_library')
+    assert @controller.template.layout.include?('layouts/third_party_template_library')
     assert_response :success
     assert_equal 'Mab', @response.body
   end
@@ -121,49 +121,49 @@ class LayoutSetInResponseTest < ActionController::TestCase
   def test_layout_set_when_using_default_layout
     @controller = DefaultLayoutController.new
     get :hello
-    assert @response.layout.include?('layouts/layout_test')
+    assert @controller.template.layout.include?('layouts/layout_test')
   end
 
   def test_layout_set_when_set_in_controller
     @controller = HasOwnLayoutController.new
     get :hello
-    assert @response.layout.include?('layouts/item')
+    assert @controller.template.layout.include?('layouts/item')
   end
   
   def test_layout_only_exception_when_included
     @controller = OnlyLayoutController.new
     get :hello
-    assert @response.layout.include?('layouts/item')
+    assert @controller.template.layout.include?('layouts/item')
   end
 
   def test_layout_only_exception_when_excepted
     @controller = OnlyLayoutController.new
     get :goodbye
-    assert_equal nil, @response.layout
+    assert_equal nil, @controller.template.layout
   end
 
   def test_layout_except_exception_when_included
     @controller = ExceptLayoutController.new
     get :hello
-    assert @response.layout.include?('layouts/item')
+    assert @controller.template.layout.include?('layouts/item')
   end
 
   def test_layout_except_exception_when_excepted
     @controller = ExceptLayoutController.new
     get :goodbye
-    assert_equal nil, @response.layout
+    assert_equal nil, @controller.template.layout
   end
 
   def test_layout_set_when_using_render
     @controller = SetsLayoutInRenderController.new
     get :hello
-    assert @response.layout.include?('layouts/third_party_template_library')
+    assert @controller.template.layout.include?('layouts/third_party_template_library')
   end
 
   def test_layout_is_not_set_when_none_rendered
     @controller = RendersNoLayoutController.new
     get :hello
-    assert_nil @response.layout
+    assert_nil @controller.template.layout
   end
 
   def test_exempt_from_layout_honored_by_render_template
@@ -181,7 +181,7 @@ class LayoutSetInResponseTest < ActionController::TestCase
     pending do
       @controller = PrependsViewPathController.new
       get :hello
-      assert_equal 'layouts/alt', @response.layout
+      assert_equal 'layouts/alt', @controller.template.layout
     end
   end
 
@@ -206,7 +206,7 @@ class LayoutExceptionRaised < ActionController::TestCase
   def test_exception_raised_when_layout_file_not_found
     @controller = SetsNonExistentLayoutFile.new
     get :hello
-    assert_kind_of ActionView::MissingTemplate, @response.template.instance_eval { @exception }
+    assert_kind_of ActionView::MissingTemplate, @controller.template.instance_eval { @exception }
   end
 end
 
@@ -234,7 +234,7 @@ unless RUBY_PLATFORM =~ /(:?mswin|mingw|bccwin)/
       @controller = LayoutSymlinkedTest.new
       get :hello
       assert_response 200
-      assert @response.layout.include?("layouts/symlinked/symlinked_layout")
+      assert @controller.template.layout.include?("layouts/symlinked/symlinked_layout")
     end
   end
 end
diff --git a/actionpack/test/template/body_parts_test.rb b/actionpack/test/template/body_parts_test.rb
index 4c82b75cdc..5be8533293 100644
--- a/actionpack/test/template/body_parts_test.rb
+++ b/actionpack/test/template/body_parts_test.rb
@@ -6,7 +6,7 @@ class BodyPartsTest < ActionController::TestCase
   class TestController < ActionController::Base
     def index
       RENDERINGS.each do |rendering|
-        response.template.punctuate_body! rendering
+        @template.punctuate_body! rendering
       end
       @performed_render = true
     end
diff --git a/actionpack/test/template/output_buffer_test.rb b/actionpack/test/template/output_buffer_test.rb
index 6d8eab63dc..bc17f36783 100644
--- a/actionpack/test/template/output_buffer_test.rb
+++ b/actionpack/test/template/output_buffer_test.rb
@@ -13,23 +13,23 @@ class OutputBufferTest < ActionController::TestCase
     # Start with the default body parts
     get :index
     assert_equal ['foo'], @response.body_parts
-    assert_nil @response.template.output_buffer
+    assert_nil @controller.template.output_buffer
 
     # Nil output buffer is skipped
-    @response.template.flush_output_buffer
-    assert_nil @response.template.output_buffer
+    @controller.template.flush_output_buffer
+    assert_nil @controller.template.output_buffer
     assert_equal ['foo'], @response.body_parts
 
     # Empty output buffer is skipped
-    @response.template.output_buffer = ''
-    @response.template.flush_output_buffer
-    assert_equal '', @response.template.output_buffer
+    @controller.template.output_buffer = ''
+    @controller.template.flush_output_buffer
+    assert_equal '', @controller.template.output_buffer
     assert_equal ['foo'], @response.body_parts
 
     # Flushing appends the output buffer to the body parts
-    @response.template.output_buffer = 'bar'
-    @response.template.flush_output_buffer
-    assert_equal '', @response.template.output_buffer
+    @controller.template.output_buffer = 'bar'
+    @controller.template.flush_output_buffer
+    assert_equal '', @controller.template.output_buffer
     assert_equal ['foo', 'bar'], @response.body_parts
   end
 end