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

This commit is contained in:
Joshua Peek 2009-04-28 23:29:29 -05:00
parent 8925e89c63
commit c0a372ba87
15 changed files with 195 additions and 142 deletions

@ -367,6 +367,8 @@ def session
# 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 @@ def _process_options(options)
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

@ -127,7 +127,7 @@ def custom(mime_type, &block)
@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

@ -121,7 +121,7 @@ def cache_layout?
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

@ -33,7 +33,7 @@ def assert_response(type, message = nil)
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 @@ def assert_template(options = {}, message = nil)
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 @@ def assert_template(options = {}, message = nil)
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

@ -160,7 +160,8 @@ def redirect_url_match?(pattern)
# 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 @@ def has_session_object?(name=nil)
# 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 @@ def xml_http_request(request_method, action, parameters = nil, session = nil, fl
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 @@ def set_test_assigns
(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

@ -34,20 +34,30 @@ class Response < Rack::Response
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'

@ -191,7 +191,7 @@ def self.cache_template_loading?
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

@ -46,7 +46,7 @@ def _render_content_with_layout(content, layout, locals)
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

@ -7,7 +7,8 @@ def initialize(*args)
@_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 @@ def _render_template(template, local_assigns = {})
@_rendered[:template] << template
end
_render_template_without_template_tracking(template, local_assigns)
end
end
end
class TestCase < ActiveSupport::TestCase

@ -292,14 +292,14 @@ def test_assert_redirected_to_top_level_named_route_with_same_controller_name_in
# 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 @@ def test_flash_have_nots
# 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

@ -165,11 +165,11 @@ class SkippingAndLimitedController < TestController
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 @@ def test_after_filters_are_not_run_if_around_filter_does_not_yield
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 @@ def test_prepending_filter
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 @@ def test_prepending_and_appending_around_filter
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 @@ def test_dynamic_dispatch
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 @@ def test_process(controller, action = "show")
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 @@ def test_with_method
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 @@ def test_nested_filters
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 @@ def test_process(controller, action = "show")
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

@ -79,64 +79,64 @@ def test_flash
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

@ -57,7 +57,7 @@ def test_third_party_template_library_auto_discovers_layout
@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 @@ def test_layout_is_picked_from_the_controller_instances_view_path
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 @@ def test_symlinked_layout_is_rendered
@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

@ -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

@ -13,23 +13,23 @@ def test_flush_output_buffer
# 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