Modify assert_template to use notifications. Also, remove ActionController::Base#template since it is no longer needed.

actionpack/lib/action_controller/metal/compatibility.rb

@@ -40,15 +40,6 @@ module ActionController
     def initialize_template_class(*) end
     def assign_shortcuts(*) end
 
-    def template
-      @template ||= view_context
-    end
-
-    def process_action(*)
-      template
-      super
-    end
-
     def _normalize_options(options)
       if options[:action] && options[:action].to_s.include?(?/)
         ActiveSupport::Deprecation.warn "Giving a path to render :action is deprecated. " <<

actionpack/lib/action_controller/test_case.rb

@@ -13,6 +13,13 @@ module ActionController
     def setup_subscriptions
       @partials = Hash.new(0)
       @templates = Hash.new(0)
+      @layouts = Hash.new(0)
+
+      ActiveSupport::Notifications.subscribe("action_view.render_template") do |name, start, finish, id, payload|
+        path = payload[:layout]
+        @layouts[path] += 1
+      end
+
       ActiveSupport::Notifications.subscribe("action_view.render_template!") do |name, start, finish, id, payload|
         path = payload[:virtual_path]
         next unless path
@@ -69,6 +76,19 @@ module ActionController
                     "expecting ? to be rendered ? time(s) but rendered ? time(s)",
                      expected_partial, expected_count, actual_count)
             assert(actual_count == expected_count.to_i, msg)
+          elsif options.key?(:layout)
+            msg = build_message(message,
+                    "expecting layout <?> but action rendered <?>",
+                    expected_layout, @layouts.keys)
+
+            case layout = options[:layout]
+            when String
+              assert(@layouts.include?(expected_layout), msg)
+            when Regexp
+              assert(@layouts.any? {|l| l =~ layout }, msg)
+            when nil
+              assert(@layouts.empty?, msg)
+            end
           else
             msg = build_message(message,
                     "expecting partial <?> but action rendered <?>",

actionpack/lib/action_view/base.rb

@@ -196,7 +196,7 @@ module ActionView #:nodoc:
     end
 
     attr_accessor :base_path, :assigns, :template_extension, :lookup_context
-    attr_internal :captures, :request, :layout, :controller, :template, :config
+    attr_internal :captures, :request, :controller, :template, :config
 
     delegate :find_template, :template_exists?, :formats, :formats=, :locale, :locale=,
              :view_paths, :view_paths=, :with_fallbacks, :update_details, :to => :lookup_context
@@ -206,6 +206,11 @@ module ActionView #:nodoc:
 
     delegate :logger, :to => :controller, :allow_nil => true
 
+    # TODO: HACK FOR RJS
+    def view_context
+      self
+    end
+
     def self.xss_safe? #:nodoc:
       true
     end
@@ -254,7 +259,7 @@ module ActionView #:nodoc:
       @helpers = self.class.helpers || Module.new
 
       @_controller   = controller
-      @_config       = ActiveSupport::InheritableOptions.new(controller.config) if controller
+      @_config       = ActiveSupport::InheritableOptions.new(controller.config) if controller && controller.respond_to?(:config)
       @_content_for  = Hash.new { |h,k| h[k] = ActiveSupport::SafeBuffer.new }
       @_virtual_path = nil
 

actionpack/lib/action_view/helpers/prototype_helper.rb

@@ -582,7 +582,7 @@ module ActionView
       #     page.hide 'spinner'
       #   end
       def update_page(&block)
-        JavaScriptGenerator.new(@template, &block).to_s.html_safe
+        JavaScriptGenerator.new(view_context, &block).to_s.html_safe
       end
 
       # Works like update_page but wraps the generated JavaScript in a <script>

actionpack/lib/action_view/render/rendering.rb

@@ -53,13 +53,12 @@ module ActionView
       layout = find_layout(layout) if layout
 
       ActiveSupport::Notifications.instrument("action_view.render_template",
-        :identifier => template.identifier, :layout => layout.try(:identifier)) do
+        :identifier => template.identifier, :layout => layout.try(:virtual_path)) do
 
         content = template.render(self, locals) { |*name| _layout_for(*name) }
         @_content_for[:layout] = content
 
         if layout
-          @_layout = layout.identifier
           content  = _render_layout(layout, locals)
         end
 

actionpack/lib/action_view/test_case.rb

@@ -4,6 +4,8 @@ require 'action_view'
 module ActionView
   class TestCase < ActiveSupport::TestCase
     class TestController < ActionController::Base
+      include ActionDispatch::TestProcess
+
       attr_accessor :request, :response, :params
 
       def self.controller_path
@@ -44,7 +46,7 @@ module ActionView
     end
 
     def config
-      @controller.config
+      @controller.config if @controller.respond_to?(:config)
     end
 
     def render(options = {}, local_assigns = {}, &block)

actionpack/test/controller/action_pack_assertions_test.rb

@@ -181,6 +181,8 @@ module Admin
   end
 end
 
+# require "action_dispatch/test_process"
+
 # a test case to exercise the new capabilities TestRequest & TestResponse
 class ActionPackAssertionsControllerTest < ActionController::TestCase
   # -- assertion-based testing ------------------------------------------------
@@ -303,14 +305,14 @@ class ActionPackAssertionsControllerTest < ActionController::TestCase
   # make sure that the template objects exist
   def test_template_objects_alive
     process :assign_this
-    assert !@controller.template.instance_variable_get(:"@hi")
+    assert !@controller.instance_variable_get(:"@hi")
-    assert @controller.template.instance_variable_get(:"@howdy")
+    assert @controller.instance_variable_get(:"@howdy")
   end
 
   # make sure we don't have template objects when we shouldn't
   def test_template_object_missing
     process :nothing
-    assert_nil @controller.template.assigns['howdy']
+    assert_nil @controller.instance_variable_get(:@howdy)
   end
 
   # check the empty flashing

actionpack/test/controller/filters_test.rb

@@ -651,9 +651,9 @@ class FilterTest < ActionController::TestCase
     assert_equal %w( ensure_login find_user ), assigns["ran_filter"]
 
     test_process(ConditionalSkippingController, "login")
-    assert_nil @controller.template.controller.instance_variable_get("@ran_after_filter")
+    assert_nil @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")
+    assert_equal %w( clean_up ), @controller.instance_variable_get("@ran_after_filter")
   end
 
   def test_conditional_skipping_of_filters_when_parent_filter_is_also_conditional

actionpack/test/controller/layout_test.rb

@@ -120,19 +120,19 @@ class LayoutSetInResponseTest < ActionController::TestCase
   def test_layout_set_when_using_default_layout
     @controller = DefaultLayoutController.new
     get :hello
-    assert @controller.template.layout.include?('layouts/layout_test')
+    assert_template :layout => "layouts/layout_test"
   end
 
   def test_layout_set_when_set_in_controller
     @controller = HasOwnLayoutController.new
     get :hello
-    assert @controller.template.layout.include?('layouts/item')
+    assert_template :layout => "layouts/item"
   end
   
   def test_layout_only_exception_when_included
     @controller = OnlyLayoutController.new
     get :hello
-    assert @controller.template.layout.include?('layouts/item')
+    assert_template :layout => "layouts/item"
   end
 
   def test_layout_only_exception_when_excepted
@@ -144,7 +144,7 @@ class LayoutSetInResponseTest < ActionController::TestCase
   def test_layout_except_exception_when_included
     @controller = ExceptLayoutController.new
     get :hello
-    assert @controller.template.layout.include?('layouts/item')
+    assert_template :layout => "layouts/item"
   end
 
   def test_layout_except_exception_when_excepted
@@ -156,19 +156,19 @@ class LayoutSetInResponseTest < ActionController::TestCase
   def test_layout_set_when_using_render
     @controller = SetsLayoutInRenderController.new
     get :hello
-    assert @controller.template.layout.include?('layouts/third_party_template_library')
+    assert_template :layout => "layouts/third_party_template_library"
   end
 
   def test_layout_is_not_set_when_none_rendered
     @controller = RendersNoLayoutController.new
     get :hello
-    assert_nil @controller.template.layout
+    assert_template :layout => nil
   end
 
   def test_layout_is_picked_from_the_controller_instances_view_path
     @controller = PrependsViewPathController.new
     get :hello
-    assert @controller.template.layout =~ /layouts\/alt\.\w+/
+    assert_template :layout => /layouts\/alt\.\w+/
   end
 
   def test_absolute_pathed_layout
@@ -219,7 +219,7 @@ unless RUBY_PLATFORM =~ /(:?mswin|mingw|bccwin)/
       @controller = LayoutSymlinkedTest.new
       get :hello
       assert_response 200
-      assert @controller.template.layout.include?("layouts/symlinked/symlinked_layout")
+      assert_template :layout => "layouts/symlinked/symlinked_layout"
     end
   end
 end

actionpack/test/controller/render_test.rb

@@ -418,7 +418,7 @@ class TestController < ActionController::Base
 
   def rendering_with_conflicting_local_vars
     @name = "David"
-    def @template.name() nil end
+    def view_context.name() nil end
     render :action => "potential_conflicts"
   end
 
@@ -526,11 +526,11 @@ class TestController < ActionController::Base
   end
 
   def partial_with_form_builder
-    render :partial => ActionView::Helpers::FormBuilder.new(:post, nil, @template, {}, Proc.new {})
+    render :partial => ActionView::Helpers::FormBuilder.new(:post, nil, view_context, {}, Proc.new {})
   end
 
   def partial_with_form_builder_subclass
-    render :partial => LabellingFormBuilder.new(:post, nil, @template, {}, Proc.new {})
+    render :partial => LabellingFormBuilder.new(:post, nil, view_context, {}, Proc.new {})
   end
 
   def partial_collection

actionpack/test/template/body_parts_test.rb

@@ -8,9 +8,8 @@ class BodyPartsTest < ActionController::TestCase
 
     def index
       RENDERINGS.each do |rendering|
-        @template.punctuate_body! rendering
+        view_context.punctuate_body! rendering
       end
-      @performed_render = true
     end
   end
 

actionpack/test/template/erb/form_for_test.rb

@@ -0,0 +1,11 @@
+require "abstract_unit"
+require "template/erb/helper"
+
+module ERBTest
+  class TagHelperTest < BlockTestCase
+    test "form_for works" do
+      output = render_content "form_for(:staticpage, :url => {:controller => 'blah', :action => 'update'})", ""
+      assert_equal "<form action=\"/blah/update\" method=\"post\"></form>", output
+    end
+  end
+end

actionpack/test/template/erb/helper.rb

@@ -0,0 +1,30 @@
+module ERBTest
+  class ViewContext
+    mock_controller = Class.new do
+      include SharedTestRoutes.url_helpers
+    end
+
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::JavaScriptHelper
+    include ActionView::Helpers::FormHelper
+
+    attr_accessor :output_buffer
+
+    def protect_against_forgery?() false end
+
+    define_method(:controller) do
+      mock_controller.new
+    end
+  end
+
+  class BlockTestCase < ActiveSupport::TestCase
+    def render_content(start, inside)
+      template = block_helper(start, inside)
+      ActionView::Template::Handlers::Erubis.new(template).evaluate(ViewContext.new)
+    end
+
+    def block_helper(str, rest)
+      "<%= #{str} do %>#{rest}<% end %>"
+    end
+  end
+end

actionpack/test/template/erb/tag_helper_test.rb

@@ -1,36 +1,10 @@
 require "abstract_unit"
+require "template/erb/helper"
 
 module ERBTest
-  class ViewContext
-    mock_controller = Class.new do
-      include SharedTestRoutes.url_helpers
-    end
-
-    include ActionView::Helpers::TagHelper
-    include ActionView::Helpers::JavaScriptHelper
-    include ActionView::Helpers::FormHelper
-
-    attr_accessor :output_buffer
-
-    def protect_against_forgery?() false end
-
-    define_method(:controller) do
-      mock_controller.new
-    end
-  end
-
-  class DeprecatedViewContext < ViewContext
-    # include ActionView::Helpers::DeprecatedBlockHelpers
-  end
-
   module SharedTagHelpers
     extend ActiveSupport::Testing::Declarative
 
-    def render_content(start, inside)
-      template = block_helper(start, inside)
-      ActionView::Template::Handlers::Erubis.new(template).evaluate(context.new)
-    end
-
     def maybe_deprecated
       if @deprecated
         assert_deprecated { yield }
@@ -64,11 +38,7 @@ module ERBTest
     end
   end
 
-  class TagHelperTest < ActiveSupport::TestCase
+  class TagHelperTest < BlockTestCase
-    def context
-      ViewContext
-    end
-
     def block_helper(str, rest)
       "<%= #{str} do %>#{rest}<% end %>"
     end
@@ -76,11 +46,7 @@ module ERBTest
     include SharedTagHelpers
   end
 
-  class DeprecatedTagHelperTest < ActiveSupport::TestCase
+  class DeprecatedTagHelperTest < BlockTestCase
-    def context
-      DeprecatedViewContext
-    end
-
     def block_helper(str, rest)
       "<% __in_erb_template=true %><% #{str} do %>#{rest}<% end %>"
     end

actionpack/test/template/output_buffer_test.rb

@@ -19,21 +19,21 @@ class OutputBufferTest < ActionController::TestCase
   end
 
   test 'flushing ignores nil output buffer' do
-    @controller.template.flush_output_buffer
+    @controller.view_context.flush_output_buffer
     assert_nil output_buffer
     assert_equal ['foo'], body_parts
   end
 
   test 'flushing ignores empty output buffer' do
-    @controller.template.output_buffer = ''
+    @controller.view_context.output_buffer = ''
-    @controller.template.flush_output_buffer
+    @controller.view_context.flush_output_buffer
     assert_equal '', output_buffer
     assert_equal ['foo'], body_parts
   end
 
   test 'flushing appends the output buffer to the body parts' do
-    @controller.template.output_buffer = 'bar'
+    @controller.view_context.output_buffer = 'bar'
-    @controller.template.flush_output_buffer
+    @controller.view_context.flush_output_buffer
     assert_equal '', output_buffer
     assert_equal ['foo', 'bar'], body_parts
   end
@@ -41,8 +41,8 @@ class OutputBufferTest < ActionController::TestCase
   if '1.9'.respond_to?(:force_encoding)
     test 'flushing preserves output buffer encoding' do
       original_buffer = ' '.force_encoding(Encoding::EUC_JP)
-      @controller.template.output_buffer = original_buffer
+      @controller.view_context.output_buffer = original_buffer
-      @controller.template.flush_output_buffer
+      @controller.view_context.flush_output_buffer
       assert_equal ['foo', original_buffer], body_parts
       assert_not_equal original_buffer, output_buffer
       assert_equal Encoding::EUC_JP, output_buffer.encoding
@@ -51,10 +51,10 @@ class OutputBufferTest < ActionController::TestCase
 
   protected
     def output_buffer
-      @controller.template.output_buffer
+      @controller.view_context.output_buffer
     end
 
     def body_parts
-      @controller.template.response.body_parts
+      @controller.response.body_parts
     end
 end