kotovalexarian-likes-github/rails--rails
1
0
Fork 0
mirror of https://github.com/rails/rails.git synced 2022-11-09 12:12:34 -05:00
Code Releases Activity

Remove assigns and assert_template.

Browse source
This commit is contained in:
Guo Xiang Tan 2015-05-13 18:28:33 +08:00
parent 109e71d2bb
commit ca83436d1b
26 changed files with 166 additions and 880 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
actionpack/CHANGELOG.md
View file

@ -1,3 +1,10 @@
* Remove `assigns` and `assert_template`. Both methods have been extracted
into a gem at https://github.com/rails/rails-controller-testing.
See #18950.
*Alan Guo Xiang Tan*
* `FileHandler` and `Static` middleware initializers accept `index` argument
to configure the directory index file name. Defaults to `index` (as in
`index.html`).

185
actionpack/lib/action_controller/template_assertions.rb
View file

@ -1,188 +1,9 @@
module ActionController
module TemplateAssertions
extend ActiveSupport::Concern
included do
setup :setup_subscriptions
teardown :teardown_subscriptions
end
RENDER_TEMPLATE_INSTANCE_VARIABLES = %w{partials templates layouts files}.freeze
def setup_subscriptions
RENDER_TEMPLATE_INSTANCE_VARIABLES.each do |instance_variable|
instance_variable_set("@_#{instance_variable}", Hash.new(0))
end
@_subscribers = []
@_subscribers << ActiveSupport::Notifications.subscribe("render_template.action_view") do |_name, _start, _finish, _id, payload|
path = payload[:layout]
if path
@_layouts[path] += 1
if path =~ /^layouts\/(.*)/
@_layouts[$1] += 1
end
end
end
@_subscribers << ActiveSupport::Notifications.subscribe("!render_template.action_view") do |_name, _start, _finish, _id, payload|
if virtual_path = payload[:virtual_path]
partial = virtual_path =~ /^.*\/_[^\/]*$/
if partial
@_partials[virtual_path] += 1
@_partials[virtual_path.split("/").last] += 1
end
@_templates[virtual_path] += 1
else
path = payload[:identifier]
if path
@_files[path] += 1
@_files[path.split("/").last] += 1
end
end
end
end
def teardown_subscriptions
@_subscribers.each do |subscriber|
ActiveSupport::Notifications.unsubscribe(subscriber)
end
end
def process(*args)
reset_template_assertion
super
end
def reset_template_assertion
RENDER_TEMPLATE_INSTANCE_VARIABLES.each do |instance_variable|
ivar_name = "@_#{instance_variable}"
if instance_variable_defined?(ivar_name)
instance_variable_get(ivar_name).clear
end
end
end
# Asserts that the request was rendered with the appropriate template file or partials.
#
# # assert that the "new" view template was rendered
# assert_template "new"
#
# # assert that the exact template "admin/posts/new" was rendered
# assert_template %r{\Aadmin/posts/new\Z}
#
# # assert that the layout 'admin' was rendered
# assert_template layout: 'admin'
# assert_template layout: 'layouts/admin'
# assert_template layout: :admin
#
# # assert that no layout was rendered
# assert_template layout: nil
# assert_template layout: false
#
# # assert that the "_customer" partial was rendered twice
# assert_template partial: '_customer', count: 2
#
# # assert that no partials were rendered
# assert_template partial: false
#
# # assert that a file was rendered
# assert_template file: "README.rdoc"
#
# # assert that no file was rendered
# assert_template file: nil
# assert_template file: false
#
# In a view test case, you can also assert that specific locals are passed
# to partials:
#
# # assert that the "_customer" partial was rendered with a specific object
# assert_template partial: '_customer', locals: { customer: @customer }
def assert_template(options = {}, message = nil)
# Force body to be read in case the template is being streamed.
response.body
case options
when NilClass, Regexp, String, Symbol
options = options.to_s if Symbol === options
rendered = @_templates
msg = message || sprintf("expecting <%s> but rendering with <%s>",
options.inspect, rendered.keys)
matches_template =
case options
when String
!options.empty? && rendered.any? do |t, num|
options_splited = options.split(File::SEPARATOR)
t_splited = t.split(File::SEPARATOR)
t_splited.last(options_splited.size) == options_splited
end
when Regexp
rendered.any? { |t,num| t.match(options) }
when NilClass
rendered.blank?
end
assert matches_template, msg
when Hash
options.assert_valid_keys(:layout, :partial, :locals, :count, :file)
if options.key?(:layout)
expected_layout = options[:layout]
msg = message || sprintf("expecting layout <%s> but action rendered <%s>",
expected_layout, @_layouts.keys)
case expected_layout
when String, Symbol
assert_includes @_layouts.keys, expected_layout.to_s, msg
when Regexp
assert(@_layouts.keys.any? {|l| l =~ expected_layout }, msg)
when nil, false
assert(@_layouts.empty?, msg)
else
raise ArgumentError, "assert_template only accepts a String, Symbol, Regexp, nil or false for :layout"
end
end
if options[:file]
assert_includes @_files.keys, options[:file]
elsif options.key?(:file)
assert @_files.blank?, "expected no files but #{@_files.keys} was rendered"
end
if expected_partial = options[:partial]
if expected_locals = options[:locals]
if defined?(@_rendered_views)
view = expected_partial.to_s.sub(/^_/, '').sub(/\/_(?=[^\/]+\z)/, '/')
partial_was_not_rendered_msg = "expected %s to be rendered but it was not." % view
assert_includes @_rendered_views.rendered_views, view, partial_was_not_rendered_msg
msg = 'expecting %s to be rendered with %s but was with %s' % [expected_partial,
expected_locals,
@_rendered_views.locals_for(view)]
assert(@_rendered_views.view_rendered?(view, options[:locals]), msg)
else
warn "the :locals option to #assert_template is only supported in a ActionView::TestCase"
end
elsif expected_count = options[:count]
actual_count = @_partials[expected_partial]
msg = message || sprintf("expecting %s to be rendered %s time(s) but rendered %s time(s)",
expected_partial, expected_count, actual_count)
assert(actual_count == expected_count.to_i, msg)
else
msg = message || sprintf("expecting partial <%s> but action rendered <%s>",
options[:partial], @_partials.keys)
assert_includes @_partials, expected_partial, msg
end
elsif options.key?(:partial)
assert @_partials.empty?,
"Expected no partials to be rendered"
end
else
raise ArgumentError, "assert_template only accepts a String, Symbol, Hash, Regexp, or nil"
end
raise NoMethodError,
"assert_template has been extracted to a gem. To continue using it,
add `gem 'rails-controller-testing'` to your Gemfile."
end
end
end

6
actionpack/lib/action_controller/test_case.rb
View file

@ -218,21 +218,15 @@ module ActionController
# In addition to these specific assertions, you also have easy access to various collections that the regular test/unit assertions
# can be used against. These collections are:
#
# * assigns: Instance variables assigned in the action that are available for the view.
# * session: Objects being saved in the session.
# * flash: The flash objects currently in the session.
# * cookies: \Cookies being sent to the user on this request.
#
# These collections can be used just like any other hash:
#
# assert_not_nil assigns(:person) # makes sure that a @person instance variable was set
# assert_equal "Dave", cookies[:name] # makes sure that a cookie called :name was set as "Dave"
# assert flash.empty? # makes sure that there's nothing in the flash
#
# For historic reasons, the assigns hash uses string-based keys. So <tt>assigns[:person]</tt> won't work, but <tt>assigns["person"]</tt> will. To
# appease our yearning for symbols, though, an alternative accessor has been devised using a method call instead of index referencing.
# So <tt>assigns(:person)</tt> will work just like <tt>assigns["person"]</tt>, but again, <tt>assigns[:person]</tt> will not work.
#
# On top of the collections, you have the complete url that a given action redirected to available in <tt>redirect_to_url</tt>.
#
# For redirects within the same controller, you can even call follow_redirect and the redirect will be followed, triggering another

1
actionpack/lib/action_dispatch/routing.rb
View file

@ -232,7 +232,6 @@ module ActionDispatch
# def send_to_jail
# get '/jail'
# assert_response :success
# assert_template "jail/front"
# end
#
# def goes_to_login

1
actionpack/lib/action_dispatch/testing/integration.rb
View file

@ -429,7 +429,6 @@ module ActionDispatch
# reset the html_document variable, except for cookies/assigns calls
unless method == 'cookies' || method == 'assigns'
@html_document = nil
reset_template_assertion
end
integration_session.__send__(method, *args).tap do

6
actionpack/lib/action_dispatch/testing/test_process.rb
View file

@ -5,9 +5,9 @@ require 'active_support/core_ext/hash/indifferent_access'
module ActionDispatch
module TestProcess
def assigns(key = nil)
assigns = {}.with_indifferent_access
@controller.view_assigns.each { |k, v| assigns.regular_writer(k, v) }
key.nil? ? assigns : assigns[key]
raise NoMethodError,
"assigns has been extracted to a gem. To continue using it,
add `gem 'rails-controller-testing'` to your Gemfile."
end
def session

209
actionpack/test/controller/action_pack_assertions_test.rb
View file

@ -5,9 +5,6 @@ class ActionPackAssertionsController < ActionController::Base
def nothing() head :ok end
def hello_world() render :template => "test/hello_world"; end
def hello_repeating_in_path() render :template => "test/hello/hello"; end
def hello_xml_world() render :template => "test/hello_xml_world"; end
def hello_xml_world_pdf
@ -20,8 +17,6 @@ class ActionPackAssertionsController < ActionController::Base
render :template => "test/hello_xml_world"
end
def partial() render :partial => 'test/partial'; end
def redirect_internal() redirect_to "/nothing"; end
def redirect_to_action() redirect_to :action => "flash_me", :id => 1, :params => { "panda" => "fun" }; end
@ -73,16 +68,6 @@ class ActionPackAssertionsController < ActionController::Base
render :text => "Hello!", :content_type => Mime::RSS
end
def render_with_layout
@variable_for_layout = nil
render "test/hello_world", :layout => "layouts/standard"
end
def render_with_layout_and_partial
@variable_for_layout = nil
render "test/hello_world_with_partial", :layout => "layouts/standard"
end
def session_stuffing
session['xmas'] = 'turkey'
render :text => "ho ho ho"
@ -304,14 +289,6 @@ class ActionPackAssertionsControllerTest < ActionController::TestCase
assert session.empty?
end
def test_render_template_action
process :nothing
assert_template nil
process :hello_world
assert_template 'hello_world'
end
def test_redirection_location
process :redirect_internal
assert_equal 'http://test.host/nothing', @response.redirect_url
@ -455,192 +432,6 @@ class ActionPackAssertionsControllerTest < ActionController::TestCase
end
end
class AssertTemplateTest < ActionController::TestCase
tests ActionPackAssertionsController
def test_with_invalid_hash_keys_raises_argument_error
assert_raise(ArgumentError) do
assert_template foo: "bar"
end
end
def test_with_partial
get :partial
assert_template :partial => '_partial'
end
def test_file_with_absolute_path_success
get :render_file_absolute_path
assert_template :file => File.expand_path('../../../README.rdoc', __FILE__)
end
def test_file_with_relative_path_success
get :render_file_relative_path
assert_template :file => 'README.rdoc'
end
def test_with_file_failure
get :render_file_absolute_path
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template :file => 'test/hello_world'
end
get :render_file_absolute_path
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template file: nil
end
end
def test_with_nil_passes_when_no_template_rendered
get :nothing
assert_template nil
end
def test_with_nil_fails_when_template_rendered
get :hello_world
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template nil
end
end
def test_with_empty_string_fails_when_template_rendered
get :hello_world
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template ""
end
end
def test_with_empty_string_fails_when_no_template_rendered
get :nothing
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template ""
end
end
def test_passes_with_correct_string
get :hello_world
assert_template 'hello_world'
assert_template 'test/hello_world'
end
def test_passes_with_correct_symbol
get :hello_world
assert_template :hello_world
end
def test_fails_with_incorrect_string
get :hello_world
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template 'hello_planet'
end
end
def test_fails_with_incorrect_string_that_matches
get :hello_world
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template 'est/he'
end
end
def test_fails_with_repeated_name_in_path
get :hello_repeating_in_path
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template 'test/hello'
end
end
def test_fails_with_incorrect_symbol
get :hello_world
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template :hello_planet
end
end
def test_fails_with_incorrect_symbol_that_matches
get :hello_world
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template :"est/he"
end
end
def test_fails_with_wrong_layout
get :render_with_layout
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template :layout => "application"
end
end
def test_fails_expecting_no_layout
get :render_with_layout
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template :layout => nil
end
end
def test_fails_expecting_not_known_layout
get :render_with_layout
assert_raise(ArgumentError) do
assert_template :layout => 1
end
end
def test_passes_with_correct_layout
get :render_with_layout
assert_template :layout => "layouts/standard"
end
def test_passes_with_layout_and_partial
get :render_with_layout_and_partial
assert_template :layout => "layouts/standard"
end
def test_passed_with_no_layout
get :hello_world
assert_template :layout => nil
end
def test_passed_with_no_layout_false
get :hello_world
assert_template :layout => false
end
def test_passes_with_correct_layout_without_layouts_prefix
get :render_with_layout
assert_template :layout => "standard"
end
def test_passes_with_correct_layout_symbol
get :render_with_layout
assert_template :layout => :standard
end
def test_assert_template_reset_between_requests
get :hello_world
assert_template 'test/hello_world'
get :nothing
assert_template nil
get :partial
assert_template partial: 'test/_partial'
get :nothing
assert_template partial: nil
get :render_with_layout
assert_template layout: 'layouts/standard'
get :nothing
assert_template layout: nil
get :render_file_relative_path
assert_template file: 'README.rdoc'
get :nothing
assert_template file: nil
end
end
class ActionPackHeaderTest < ActionController::TestCase
tests ActionPackAssertionsController

151
actionpack/test/controller/filters_test.rb
View file

@ -13,16 +13,6 @@ class ActionController::Base
filters.map!(&:raw_filter)
end
end
def assigns(key = nil)
assigns = {}
instance_variables.each do |ivar|
next if ActionController::Base.protected_instance_variables.include?(ivar)
assigns[ivar[1..-1]] = instance_variable_get(ivar)
end
key.nil? ? assigns : assigns[key.to_s]
end
end
class FilterTest < ActionController::TestCase
@ -560,7 +550,7 @@ class FilterTest < ActionController::TestCase
def test_after_actions_are_not_run_if_around_action_does_not_yield
controller = NonYieldingAroundFilterController.new
test_process(controller, "index")
assert_equal ["filter_one", "it didn't yield"], controller.assigns['filters']
assert_equal ["filter_one", "it didn't yield"], controller.instance_variable_get(:@filters)
end
def test_added_action_to_inheritance_graph
@ -577,140 +567,141 @@ class FilterTest < ActionController::TestCase
def test_running_actions
test_process(PrependingController)
assert_equal %w( wonderful_life ensure_login ), assigns["ran_filter"]
assert_equal %w( wonderful_life ensure_login ),
@controller.instance_variable_get(:@ran_filter)
end
def test_running_actions_with_proc
test_process(ProcController)
assert assigns["ran_proc_action"]
assert @controller.instance_variable_get(:@ran_proc_action)
end
def test_running_actions_with_implicit_proc
test_process(ImplicitProcController)
assert assigns["ran_proc_action"]
assert @controller.instance_variable_get(:@ran_proc_action)
end
def test_running_actions_with_class
test_process(AuditController)
assert assigns["was_audited"]
assert @controller.instance_variable_get(:@was_audited)
end
def test_running_anomolous_yet_valid_condition_actions
test_process(AnomolousYetValidConditionController)
assert_equal %w( ensure_login ), assigns["ran_filter"]
assert assigns["ran_class_action"]
assert assigns["ran_proc_action1"]
assert assigns["ran_proc_action2"]
assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
assert @controller.instance_variable_get(:@ran_class_action)
assert @controller.instance_variable_get(:@ran_proc_action1)
assert @controller.instance_variable_get(:@ran_proc_action2)
test_process(AnomolousYetValidConditionController, "show_without_action")
assert_nil assigns["ran_filter"]
assert !assigns["ran_class_action"]
assert !assigns["ran_proc_action1"]
assert !assigns["ran_proc_action2"]
assert_not @controller.instance_variable_defined?(:@ran_filter)
assert_not @controller.instance_variable_defined?(:@ran_class_action)
assert_not @controller.instance_variable_defined?(:@ran_proc_action1)
assert_not @controller.instance_variable_defined?(:@ran_proc_action2)
end
def test_running_conditional_options
test_process(ConditionalOptionsFilter)
assert_equal %w( ensure_login ), assigns["ran_filter"]
assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
end
def test_running_conditional_skip_options
test_process(ConditionalOptionsSkipFilter)
assert_equal %w( ensure_login ), assigns["ran_filter"]
assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
end
def test_if_is_ignored_when_used_with_only
test_process(SkipFilterUsingOnlyAndIf, 'login')
assert_nil assigns['ran_filter']
assert_not @controller.instance_variable_defined?(:@ran_filter)
end
def test_except_is_ignored_when_used_with_if
test_process(SkipFilterUsingIfAndExcept, 'login')
assert_equal %w(ensure_login), assigns["ran_filter"]
assert_equal %w(ensure_login), @controller.instance_variable_get(:@ran_filter)
end
def test_skipping_class_actions
test_process(ClassController)
assert_equal true, assigns["ran_class_action"]
assert_equal true, @controller.instance_variable_get(:@ran_class_action)
skipping_class_controller = Class.new(ClassController) do
skip_before_action ConditionalClassFilter
end
test_process(skipping_class_controller)
assert_nil assigns['ran_class_action']
assert_not @controller.instance_variable_defined?(:@ran_class_action)
end
def test_running_collection_condition_actions
test_process(ConditionalCollectionFilterController)
assert_equal %w( ensure_login ), assigns["ran_filter"]
assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
test_process(ConditionalCollectionFilterController, "show_without_action")
assert_nil assigns["ran_filter"]
assert_not @controller.instance_variable_defined?(:@ran_filter)
test_process(ConditionalCollectionFilterController, "another_action")
assert_nil assigns["ran_filter"]
assert_not @controller.instance_variable_defined?(:@ran_filter)
end
def test_running_only_condition_actions
test_process(OnlyConditionSymController)
assert_equal %w( ensure_login ), assigns["ran_filter"]
assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
test_process(OnlyConditionSymController, "show_without_action")
assert_nil assigns["ran_filter"]
assert_not @controller.instance_variable_defined?(:@ran_filter)
test_process(OnlyConditionProcController)
assert assigns["ran_proc_action"]
assert @controller.instance_variable_get(:@ran_proc_action)
test_process(OnlyConditionProcController, "show_without_action")
assert !assigns["ran_proc_action"]
assert_not @controller.instance_variable_defined?(:@ran_proc_action)
test_process(OnlyConditionClassController)
assert assigns["ran_class_action"]
assert @controller.instance_variable_get(:@ran_class_action)
test_process(OnlyConditionClassController, "show_without_action")
assert !assigns["ran_class_action"]
assert_not @controller.instance_variable_defined?(:@ran_class_action)
end
def test_running_except_condition_actions
test_process(ExceptConditionSymController)
assert_equal %w( ensure_login ), assigns["ran_filter"]
assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
test_process(ExceptConditionSymController, "show_without_action")
assert_nil assigns["ran_filter"]
assert_not @controller.instance_variable_defined?(:@ran_filter)
test_process(ExceptConditionProcController)
assert assigns["ran_proc_action"]
assert @controller.instance_variable_get(:@ran_proc_action)
test_process(ExceptConditionProcController, "show_without_action")
assert !assigns["ran_proc_action"]
assert_not @controller.instance_variable_defined?(:@ran_proc_action)
test_process(ExceptConditionClassController)
assert assigns["ran_class_action"]
assert @controller.instance_variable_get(:@ran_class_action)
test_process(ExceptConditionClassController, "show_without_action")
assert !assigns["ran_class_action"]
assert_not @controller.instance_variable_defined?(:@ran_class_action)
end
def test_running_only_condition_and_conditional_options
test_process(OnlyConditionalOptionsFilter, "show")
assert_not assigns["ran_conditional_index_proc"]
assert_not @controller.instance_variable_defined?(:@ran_conditional_index_proc)
end
def test_running_before_and_after_condition_actions
test_process(BeforeAndAfterConditionController)
assert_equal %w( ensure_login clean_up_tmp), assigns["ran_filter"]
assert_equal %w( ensure_login clean_up_tmp), @controller.instance_variable_get(:@ran_filter)
test_process(BeforeAndAfterConditionController, "show_without_action")
assert_nil assigns["ran_filter"]
assert_not @controller.instance_variable_defined?(:@ran_filter)
end
def test_around_action
test_process(AroundFilterController)
assert assigns["before_ran"]
assert assigns["after_ran"]
assert @controller.instance_variable_get(:@before_ran)
assert @controller.instance_variable_get(:@after_ran)
end
def test_before_after_class_action
test_process(BeforeAfterClassFilterController)
assert assigns["before_ran"]
assert assigns["after_ran"]
assert @controller.instance_variable_get(:@before_ran)
assert @controller.instance_variable_get(:@after_ran)
end
def test_having_properties_in_around_action
test_process(AroundFilterController)
assert_equal "before and after", assigns["execution_log"]
assert_equal "before and after", @controller.instance_variable_get(:@execution_log)
end
def test_prepending_and_appending_around_action
@ -723,33 +714,33 @@ class FilterTest < ActionController::TestCase
def test_rendering_breaks_actioning_chain
response = test_process(RenderingController)
assert_equal "something else", response.body
assert !assigns["ran_action"]
assert_not @controller.instance_variable_defined?(:@ran_action)
end
def test_before_action_rendering_breaks_actioning_chain_for_after_action
test_process(RenderingController)
assert_equal %w( before_action_rendering ), assigns["ran_filter"]
assert !assigns["ran_action"]
assert_equal %w( before_action_rendering ), @controller.instance_variable_get(:@ran_filter)
assert_not @controller.instance_variable_defined?(:@ran_action)
end
def test_before_action_redirects_breaks_actioning_chain_for_after_action
test_process(BeforeActionRedirectionController)
assert_response :redirect
assert_equal "http://test.host/filter_test/before_action_redirection/target_of_redirection", redirect_to_url
assert_equal %w( before_action_redirects ), assigns["ran_filter"]
assert_equal %w( before_action_redirects ), @controller.instance_variable_get(:@ran_filter)
end
def test_before_action_rendering_breaks_actioning_chain_for_preprend_after_action
test_process(RenderingForPrependAfterActionController)
assert_equal %w( before_action_rendering ), assigns["ran_filter"]
assert !assigns["ran_action"]
assert_equal %w( before_action_rendering ), @controller.instance_variable_get(:@ran_filter)
assert_not @controller.instance_variable_defined?(:@ran_action)
end
def test_before_action_redirects_breaks_actioning_chain_for_preprend_after_action
test_process(BeforeActionRedirectionForPrependAfterActionController)
assert_response :redirect
assert_equal "http://test.host/filter_test/before_action_redirection_for_prepend_after_action/target_of_redirection", redirect_to_url
assert_equal %w( before_action_redirects ), assigns["ran_filter"]
assert_equal %w( before_action_redirects ), @controller.instance_variable_get(:@ran_filter)
end
def test_actions_with_mixed_specialization_run_in_order
@ -775,26 +766,26 @@ class FilterTest < ActionController::TestCase
def test_running_prepended_before_and_after_action
test_process(PrependingBeforeAndAfterController)
assert_equal %w( before_all between_before_all_and_after_all after_all ), assigns["ran_filter"]
assert_equal %w( before_all between_before_all_and_after_all after_all ), @controller.instance_variable_get(:@ran_filter)
end
def test_skipping_and_limiting_controller
test_process(SkippingAndLimitedController, "index")
assert_equal %w( ensure_login ), assigns["ran_filter"]
assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
test_process(SkippingAndLimitedController, "public")
assert_nil assigns["ran_filter"]
assert_not @controller.instance_variable_defined?(:@ran_filter)
end
def test_skipping_and_reordering_controller
test_process(SkippingAndReorderingController, "index")
assert_equal %w( find_record ensure_login ), assigns["ran_filter"]
assert_equal %w( find_record ensure_login ), @controller.instance_variable_get(:@ran_filter)
end
def test_conditional_skipping_of_actions
test_process(ConditionalSkippingController, "login")
assert_nil assigns["ran_filter"]
assert_not @controller.instance_variable_defined?(:@ran_filter)
test_process(ConditionalSkippingController, "change_password")
assert_equal %w( ensure_login find_user ), assigns["ran_filter"]
assert_equal %w( ensure_login find_user ), @controller.instance_variable_get(:@ran_filter)
test_process(ConditionalSkippingController, "login")
assert !@controller.instance_variable_defined?("@ran_after_action")
@ -804,23 +795,23 @@ class FilterTest < ActionController::TestCase
def test_conditional_skipping_of_actions_when_parent_action_is_also_conditional
test_process(ChildOfConditionalParentController)
assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), assigns['ran_filter']
assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), @controller.instance_variable_get(:@ran_filter)
test_process(ChildOfConditionalParentController, 'another_action')
assert_nil assigns['ran_filter']
assert_not @controller.instance_variable_defined?(:@ran_filter)
end
def test_condition_skipping_of_actions_when_siblings_also_have_conditions
test_process(ChildOfConditionalParentController)
assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), assigns['ran_filter']
assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), @controller.instance_variable_get(:@ran_filter)
test_process(AnotherChildOfConditionalParentController)
assert_equal %w( conditional_in_parent_after ), assigns['ran_filter']
assert_equal %w( conditional_in_parent_after ), @controller.instance_variable_get(:@ran_filter)
test_process(ChildOfConditionalParentController)
assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), assigns['ran_filter']
assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), @controller.instance_variable_get(:@ran_filter)
end
def test_changing_the_requirements
test_process(ChangingTheRequirementsController, "go_wild")
assert_nil assigns['ran_filter']
assert_not @controller.instance_variable_defined?(:@ran_filter)
end
def test_a_rescuing_around_action
@ -835,13 +826,13 @@ class FilterTest < ActionController::TestCase
def test_actions_obey_only_and_except_for_implicit_actions
test_process(ImplicitActionsController, 'show')
assert_equal 'Except', assigns(:except)
assert_nil assigns(:only)
assert_equal 'Except', @controller.instance_variable_get(:@except)
assert_not @controller.instance_variable_defined?(:@only)
assert_equal 'show', response.body
test_process(ImplicitActionsController, 'edit')
assert_equal 'Only', assigns(:only)
assert_nil assigns(:except)
assert_equal 'Only', @controller.instance_variable_get(:@only)
assert_not @controller.instance_variable_defined?(:@except)
assert_equal 'edit', response.body
end
@ -1010,8 +1001,8 @@ class YieldingAroundFiltersTest < ActionController::TestCase
def test_with_proc
test_process(ControllerWithProcFilter,'no_raise')
assert assigns['before']
assert assigns['after']
assert @controller.instance_variable_get(:@before)
assert @controller.instance_variable_get(:@after)
end
def test_nested_actions
@ -1032,12 +1023,12 @@ class YieldingAroundFiltersTest < ActionController::TestCase
def test_action_order_with_all_action_types
test_process(ControllerWithAllTypesOfFilters,'no_raise')
assert_equal 'before around (before yield) around_again (before yield) around_again (after yield) after around (after yield)', assigns['ran_filter'].join(' ')
assert_equal 'before around (before yield) around_again (before yield) around_again (after yield) after around (after yield)', @controller.instance_variable_get(:@ran_filter).join(' ')
end
def test_action_order_with_skip_action_method
test_process(ControllerWithTwoLessFilters,'no_raise')
assert_equal 'before around (before yield) around (after yield)', assigns['ran_filter'].join(' ')
assert_equal 'before around (before yield) around (after yield)', @controller.instance_variable_get(:@ran_filter).join(' ')
end
def test_first_action_in_multiple_before_action_chain_halts
@ -1063,7 +1054,7 @@ class YieldingAroundFiltersTest < ActionController::TestCase
def test_skipping_with_skip_action_callback
test_process(SkipFilterUsingSkipActionCallback,'no_raise')
assert_equal 'before around (before yield) around (after yield)', assigns['ran_filter'].join(' ')
assert_equal 'before around (before yield) around (after yield)', @controller.instance_variable_get(:@ran_filter).join(' ')
end
def test_deprecated_skip_action_callback

49
actionpack/test/controller/flash_test.rb
View file

@ -103,54 +103,55 @@ class FlashTest < ActionController::TestCase
get :set_flash
get :use_flash
assert_equal "hello", assigns["flash_copy"]["that"]
assert_equal "hello", assigns["flashy"]
assert_equal "hello", @controller.instance_variable_get(:@flash_copy)["that"]
assert_equal "hello", @controller.instance_variable_get(:@flashy)
get :use_flash
assert_nil assigns["flash_copy"]["that"], "On second flash"
assert_nil @controller.instance_variable_get(:@flash_copy)["that"], "On second flash"
end
def test_keep_flash
get :set_flash
get :use_flash_and_keep_it
assert_equal "hello", assigns["flash_copy"]["that"]
assert_equal "hello", assigns["flashy"]
assert_equal "hello", @controller.instance_variable_get(:@flash_copy)["that"]
assert_equal "hello", @controller.instance_variable_get(:@flashy)
get :use_flash
assert_equal "hello", assigns["flash_copy"]["that"], "On second flash"
assert_equal "hello", @controller.instance_variable_get(:@flash_copy)["that"], "On second flash"
get :use_flash
assert_nil assigns["flash_copy"]["that"], "On third flash"
assert_nil @controller.instance_variable_get(:@flash_copy)["that"], "On third flash"
end
def test_flash_now
get :set_flash_now
assert_equal "hello", assigns["flash_copy"]["that"]
assert_equal "bar" , assigns["flash_copy"]["foo"]
assert_equal "hello", assigns["flashy"]
assert_equal "hello", @controller.instance_variable_get(:@flash_copy)["that"]
assert_equal "bar", @controller.instance_variable_get(:@flash_copy)["foo"]
assert_equal "hello", @controller.instance_variable_get(:@flashy)
get :attempt_to_use_flash_now
assert_nil assigns["flash_copy"]["that"]
assert_nil assigns["flash_copy"]["foo"]
assert_nil assigns["flashy"]
assert_nil @controller.instance_variable_get(:@flash_copy)["that"]
assert_nil @controller.instance_variable_get(:@flash_copy)["foo"]
assert_nil @controller.instance_variable_get(:@flashy)
end
def test_update_flash
get :set_flash
get :use_flash_and_update_it
assert_equal "hello", assigns["flash_copy"]["that"]
assert_equal "hello again", assigns["flash_copy"]["this"]
assert_equal "hello", @controller.instance_variable_get(:@flash_copy)["that"]
assert_equal "hello again", @controller.instance_variable_get(:@flash_copy)["this"]
get :use_flash
assert_nil assigns["flash_copy"]["that"], "On second flash"
assert_equal "hello again", assigns["flash_copy"]["this"], "On second flash"
assert_nil @controller.instance_variable_get(:@flash_copy)["that"], "On second flash"
assert_equal "hello again",
@controller.instance_variable_get(:@flash_copy)["this"], "On second flash"
end
def test_flash_after_reset_session
get :use_flash_after_reset_session
assert_equal "hello", assigns["flashy_that"]
assert_equal "good-bye", assigns["flashy_this"]
assert_nil assigns["flashy_that_reset"]
assert_equal "hello", @controller.instance_variable_get(:@flashy_that)
assert_equal "good-bye", @controller.instance_variable_get(:@flashy_this)
assert_nil @controller.instance_variable_get(:@flashy_that_reset)
end
def test_does_not_set_the_session_if_the_flash_is_empty
@ -160,13 +161,13 @@ class FlashTest < ActionController::TestCase
def test_sweep_after_halted_action_chain
get :std_action
assert_nil assigns["flash_copy"]["foo"]
assert_nil @controller.instance_variable_get(:@flash_copy)["foo"]
get :filter_halting_action
assert_equal "bar", assigns["flash_copy"]["foo"]
assert_equal "bar", @controller.instance_variable_get(:@flash_copy)["foo"]
get :std_action # follow redirection
assert_equal "bar", assigns["flash_copy"]["foo"]
assert_equal "bar", @controller.instance_variable_get(:@flash_copy)["foo"]
get :std_action
assert_nil assigns["flash_copy"]["foo"]
assert_nil @controller.instance_variable_get(:@flash_copy)["foo"]
end
def test_keep_and_discard_return_values

4
actionpack/test/controller/force_ssl_test.rb
View file

@ -240,8 +240,8 @@ class ForceSSLFlashTest < ActionController::TestCase
@request.env.delete('PATH_INFO')
get :use_flash
assert_equal "hello", assigns["flash_copy"]["that"]
assert_equal "hello", assigns["flashy"]
assert_equal "hello", @controller.instance_variable_get("@flash_copy")["that"]
assert_equal "hello", @controller.instance_variable_get("@flashy")
end
end

3
actionpack/test/controller/http_basic_authentication_test.rb
View file

@ -13,7 +13,7 @@ class HttpBasicAuthenticationTest < ActionController::TestCase
end
def display
render :text => 'Definitely Maybe'
render :text => 'Definitely Maybe' if @logged_in
end
def show
@ -122,7 +122,6 @@ class HttpBasicAuthenticationTest < ActionController::TestCase
get :display
assert_response :success
assert assigns(:logged_in)
assert_equal 'Definitely Maybe', @response.body
end

11
actionpack/test/controller/http_digest_authentication_test.rb
View file

@ -14,7 +14,7 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
end
def display
render :text => 'Definitely Maybe'
render :text => 'Definitely Maybe' if @logged_in
end
private
@ -124,7 +124,6 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
get :display
assert_response :success
assert assigns(:logged_in)
assert_equal 'Definitely Maybe', @response.body
end
@ -134,7 +133,6 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
get :display
assert_response :success
assert assigns(:logged_in)
assert_equal 'Definitely Maybe', @response.body
end
@ -144,7 +142,6 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
get :display
assert_response :success
assert assigns(:logged_in)
assert_equal 'Definitely Maybe', @response.body
end
@ -156,7 +153,6 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
get :display
assert_response :success
assert assigns(:logged_in)
assert_equal 'Definitely Maybe', @response.body
end
@ -167,7 +163,6 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
get :display
assert_response :success
assert assigns(:logged_in)
assert_equal 'Definitely Maybe', @response.body
end
@ -180,7 +175,6 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
get :display
assert_response :success
assert assigns(:logged_in)
assert_equal 'Definitely Maybe', @response.body
end
@ -191,7 +185,6 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
get :display
assert_response :success
assert assigns(:logged_in)
assert_equal 'Definitely Maybe', @response.body
end
@ -201,7 +194,6 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
put :display
assert_response :success
assert assigns(:logged_in)
assert_equal 'Definitely Maybe', @response.body
end
@ -244,7 +236,6 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
get :display
assert_response :success
assert assigns(:logged_in)
assert_equal 'Definitely Maybe', @response.body
end

2
actionpack/test/controller/integration_test.rb
View file

@ -315,8 +315,6 @@ class IntegrationTestTest < ActiveSupport::TestCase
session1 = @test.open_session { |sess| }
session2 = @test.open_session # implicit session
assert_respond_to session1, :assert_template, "open_session makes assert_template available"
assert_respond_to session2, :assert_template, "open_session makes assert_template available"
assert !session1.equal?(session2)
end

11
actionpack/test/controller/redirect_test.rb
View file

@ -50,11 +50,6 @@ class RedirectController < ActionController::Base
redirect_to :controller => 'module_test/module_redirect', :action => "hello_world"
end
def redirect_with_assigns
@hello = "world"
redirect_to :action => "hello_world"
end
def redirect_to_url
redirect_to "http://www.rubyonrails.org/"
end
@ -215,12 +210,6 @@ class RedirectTest < ActionController::TestCase
assert_redirected_to :controller => 'module_test/module_redirect', :action => 'hello_world'
end
def test_redirect_with_assigns
get :redirect_with_assigns
assert_response :redirect
assert_equal "world", assigns["hello"]
end
def test_redirect_to_url
get :redirect_to_url
assert_response :redirect

41
actionpack/test/controller/test_case_test.rb
View file

@ -140,12 +140,6 @@ XML
head :ok
end
def test_assigns
@foo = "foo"
@foo_hash = { foo: :bar }
head :ok
end
def test_without_body
render html: '<div class="foo"></div>'.html_safe
end
@ -174,17 +168,6 @@ XML
end
end
class ViewAssignsController < ActionController::Base
def test_assigns
@foo = "foo"
head :ok
end
def view_assigns
{ "bar" => "bar" }
end
end
class DefaultUrlOptionsCachingController < ActionController::Base
before_action { @dynamic_opt = 'opt' }
@ -446,30 +429,6 @@ XML
assert_equal "OK", @response.body
end
def test_assigns
process :test_assigns
# assigns can be accessed using assigns(key)
# or assigns[key], where key is a string or
# a symbol
assert_equal "foo", assigns(:foo)
assert_equal "foo", assigns("foo")
assert_equal "foo", assigns[:foo]
assert_equal "foo", assigns["foo"]
# but the assigned variable should not have its own keys stringified
expected_hash = { foo: :bar }
assert_equal expected_hash, assigns(:foo_hash)
end
def test_view_assigns
@controller = ViewAssignsController.new
process :test_assigns
assert_equal nil, assigns(:foo)
assert_equal nil, assigns[:foo]
assert_equal "bar", assigns(:bar)
assert_equal "bar", assigns[:bar]
end
def test_should_not_impose_childless_html_tags_in_xml
process :test_xml_output

110
actionpack/test/dispatch/template_assertions_test.rb
View file

@ -1,110 +0,0 @@
require 'abstract_unit'
class AssertTemplateController < ActionController::Base
def render_with_partial
render partial: 'test/partial'
end
def render_with_template
render 'test/hello_world'
end
def render_with_layout
@variable_for_layout = 'hello'
render 'test/hello_world', layout: "layouts/standard"
end
def render_with_file
render file: 'README.rdoc'
end
def render_nothing
head :ok
end
end
class AssertTemplateControllerTest < ActionDispatch::IntegrationTest
def test_template_reset_between_requests
get '/assert_template/render_with_template'
assert_template 'test/hello_world'
get '/assert_template/render_nothing'
assert_template nil
end
def test_partial_reset_between_requests
get '/assert_template/render_with_partial'
assert_template partial: 'test/_partial'
get '/assert_template/render_nothing'
assert_template partial: nil
end
def test_layout_reset_between_requests
get '/assert_template/render_with_layout'
assert_template layout: 'layouts/standard'
get '/assert_template/render_nothing'
assert_template layout: nil
end
def test_file_reset_between_requests
get '/assert_template/render_with_file'
assert_template file: 'README.rdoc'
get '/assert_template/render_nothing'
assert_template file: nil
end
def test_template_reset_between_requests_when_opening_a_session
open_session do |session|
session.get '/assert_template/render_with_template'
session.assert_template 'test/hello_world'
session.get '/assert_template/render_nothing'
session.assert_template nil
end
end
def test_partial_reset_between_requests_when_opening_a_session
open_session do |session|
session.get '/assert_template/render_with_partial'
session.assert_template partial: 'test/_partial'
session.get '/assert_template/render_nothing'
session.assert_template partial: nil
end
end
def test_layout_reset_between_requests_when_opening_a_session
open_session do |session|
session.get '/assert_template/render_with_layout'
session.assert_template layout: 'layouts/standard'
session.get '/assert_template/render_nothing'
session.assert_template layout: nil
end
end
def test_file_reset_between_requests_when_opening_a_session
open_session do |session|
session.get '/assert_template/render_with_file'
session.assert_template file: 'README.rdoc'
session.get '/assert_template/render_nothing'
session.assert_template file: nil
end
end
def test_assigns_do_not_reset_template_assertion
get '/assert_template/render_with_layout'
assert_equal 'hello', assigns(:variable_for_layout)
assert_template layout: 'layouts/standard'
end
def test_cookies_do_not_reset_template_assertion
get '/assert_template/render_with_layout'
cookies
assert_template layout: 'layouts/standard'
end
end

2
actionpack/test/fixtures/layouts/standard.html.erb vendored
View file

@ -1 +1 @@
<html><%= yield %><%= @variable_for_layout %></html>
<html><%= yield %><%= @variable_for_layout %></html>

28
actionview/test/actionpack/controller/layout_test.rb
View file

@ -157,75 +157,75 @@ class LayoutSetInResponseTest < ActionController::TestCase
def test_layout_set_when_using_default_layout
@controller = DefaultLayoutController.new
get :hello
assert_template :layout => "layouts/layout_test"
assert_includes @response.body, 'layout_test.erb'
end
def test_layout_set_when_using_streaming_layout
@controller = StreamingLayoutController.new
get :hello
assert_template :hello
assert_includes @response.body, 'layout_test.erb'
end
def test_layout_set_when_set_in_controller
@controller = HasOwnLayoutController.new
get :hello
assert_template :layout => "layouts/item"
assert_includes @response.body, 'item.erb'
end
def test_layout_symbol_set_in_controller_returning_nil_falls_back_to_default
@controller = HasNilLayoutSymbol.new
get :hello
assert_template layout: "layouts/layout_test"
assert_includes @response.body, 'layout_test.erb'
end
def test_layout_proc_set_in_controller_returning_nil_falls_back_to_default
@controller = HasNilLayoutProc.new
get :hello
assert_template layout: "layouts/layout_test"
assert_includes @response.body, 'layout_test.erb'
end
def test_layout_only_exception_when_included
@controller = OnlyLayoutController.new
get :hello
assert_template :layout => "layouts/item"
assert_includes @response.body, 'item.erb'
end
def test_layout_only_exception_when_excepted
@controller = OnlyLayoutController.new
get :goodbye
assert !@response.body.include?("item.erb"), "#{@response.body.inspect} included 'item.erb'"
assert_not_includes @response.body, 'item.erb'
end
def test_layout_except_exception_when_included
@controller = ExceptLayoutController.new
get :hello
assert_template :layout => "layouts/item"
assert_includes @response.body, 'item.erb'
end
def test_layout_except_exception_when_excepted
@controller = ExceptLayoutController.new
get :goodbye
assert !@response.body.include?("item.erb"), "#{@response.body.inspect} included 'item.erb'"
assert_not_includes @response.body, 'item.erb'
end
def test_layout_set_when_using_render
with_template_handler :mab, lambda { |template| template.source.inspect } do
@controller = SetsLayoutInRenderController.new
get :hello
assert_template :layout => "layouts/third_party_template_library"
assert_includes @response.body, 'layouts/third_party_template_library.mab'
end
end
def test_layout_is_not_set_when_none_rendered
@controller = RendersNoLayoutController.new
get :hello
assert_template :layout => nil
assert_equal 'hello.erb', @response.body
end
def test_layout_is_picked_from_the_controller_instances_view_path
@controller = PrependsViewPathController.new
get :hello
assert_template :layout => /layouts\/alt/
assert_includes @response.body, 'alt.erb'
end
def test_absolute_pathed_layout
@ -237,7 +237,7 @@ class LayoutSetInResponseTest < ActionController::TestCase
def test_respect_to_parent_layout
@controller = ChildController.new
get :goodbye
assert_template :layout => "layouts/item"
assert_includes @response.body, 'item.erb'
end
end
@ -276,7 +276,7 @@ unless RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
@controller = LayoutSymlinkedTest.new
get :hello
assert_response 200
assert_template :layout => "layouts/symlinked/symlinked_layout"
assert_includes @response.body, 'This is my layout'
end
end
end

66
actionview/test/actionpack/controller/render_test.rb
View file

@ -692,20 +692,19 @@ class RenderTest < ActionController::TestCase
get :hello_world
assert_response 200
assert_response :success
assert_template "test/hello_world"
assert_equal "<html>Hello world!</html>", @response.body
end
# :ported:
def test_renders_default_template_for_missing_action
get :'hyphen-ated'
assert_template 'test/hyphen-ated'
assert_equal "hyphen-ated.erb", @response.body
end
# :ported:
def test_render
get :render_hello_world
assert_template "test/hello_world"
assert_equal "Hello world!", @response.body
end
def test_line_offset
@ -721,20 +720,18 @@ class RenderTest < ActionController::TestCase
# :ported: compatibility
def test_render_with_forward_slash
get :render_hello_world_with_forward_slash
assert_template "test/hello_world"
assert_equal "Hello world!", @response.body
end
# :ported:
def test_render_in_top_directory
get :render_template_in_top_directory
assert_template "shared"
assert_equal "Elastica", @response.body
end
# :ported:
def test_render_in_top_directory_with_slash
get :render_template_in_top_directory_with_slash
assert_template "shared"
assert_equal "Elastica", @response.body
end
@ -752,7 +749,7 @@ class RenderTest < ActionController::TestCase
# :ported:
def test_render_action
get :render_action_hello_world
assert_template "test/hello_world"
assert_equal "Hello world!", @response.body
end
def test_render_action_upcased
@ -764,7 +761,7 @@ class RenderTest < ActionController::TestCase
end
else
get action
assert_template 'test/Hello_world'
assert_equal 'Hello world!', @response.body
end
end
@ -772,13 +769,12 @@ class RenderTest < ActionController::TestCase
def test_render_action_hello_world_as_string
get :render_action_hello_world_as_string
assert_equal "Hello world!", @response.body
assert_template "test/hello_world"
end
# :ported:
def test_render_action_with_symbol
get :render_action_hello_world_with_symbol
assert_template "test/hello_world"
assert_equal "Hello world!", @response.body
end
# :ported:
@ -966,7 +962,7 @@ class RenderTest < ActionController::TestCase
def test_render_to_string_inline
get :render_to_string_with_inline_and_render
assert_template "test/hello_world"
assert_equal 'Hello world!', @response.body
end
# :ported:
@ -1051,8 +1047,8 @@ class RenderTest < ActionController::TestCase
def test_render_to_string_doesnt_break_assigns
get :render_to_string_with_assigns
assert_equal "i'm before the render", assigns(:before)
assert_equal "i'm after the render", assigns(:after)
assert_equal "i'm before the render", @controller.instance_variable_get(:@before)
assert_equal "i'm after the render", @controller.instance_variable_get(:@after)
end
def test_bad_render_to_string_still_throws_exception
@ -1061,8 +1057,8 @@ class RenderTest < ActionController::TestCase
def test_render_to_string_that_throws_caught_exception_doesnt_break_assigns
assert_nothing_raised { get :render_to_string_with_caught_exception }
assert_equal "i'm before the render", assigns(:before)
assert_equal "i'm after the render", assigns(:after)
assert_equal "i'm before the render", @controller.instance_variable_get(:@before)
assert_equal "i'm after the render", @controller.instance_variable_get(:@after)
end
def test_accessing_params_in_template_with_layout
@ -1123,7 +1119,7 @@ class RenderTest < ActionController::TestCase
# :addressed:
def test_render_text_with_assigns
get :render_text_with_assigns
assert_equal "world", assigns["hello"]
assert_equal "world", @controller.instance_variable_get(:@hello)
end
def test_render_text_with_assigns_option
@ -1189,22 +1185,22 @@ class RenderTest < ActionController::TestCase
def test_render_to_string_partial
get :render_to_string_with_partial
assert_equal "only partial", assigns(:partial_only)
assert_equal "Hello: david", assigns(:partial_with_locals)
assert_equal "only partial", @controller.instance_variable_get(:@partial_only)
assert_equal "Hello: david", @controller.instance_variable_get(:@partial_with_locals)
assert_equal "text/html", @response.content_type
end
def test_render_to_string_with_template_and_html_partial
get :render_to_string_with_template_and_html_partial
assert_equal "**only partial**\n", assigns(:text)
assert_equal "<strong>only partial</strong>\n", assigns(:html)
assert_equal "**only partial**\n", @controller.instance_variable_get(:@text)
assert_equal "<strong>only partial</strong>\n", @controller.instance_variable_get(:@html)
assert_equal "<strong>only html partial</strong>\n", @response.body
assert_equal "text/html", @response.content_type
end
def test_render_to_string_and_render_with_different_formats
get :render_to_string_and_render_with_different_formats
assert_equal "<strong>only partial</strong>\n", assigns(:html)
assert_equal "<strong>only partial</strong>\n", @controller.instance_variable_get(:@html)
assert_equal "**only partial**\n", @response.body
assert_equal "text/plain", @response.content_type
end
@ -1228,21 +1224,18 @@ class RenderTest < ActionController::TestCase
def test_partial_with_form_builder
get :partial_with_form_builder
assert_match(/<label/, @response.body)
assert_template('test/_form')
assert_equal "<label for=\"post_title\">Title</label>\n", @response.body
end
def test_partial_with_form_builder_subclass
get :partial_with_form_builder_subclass
assert_match(/<label/, @response.body)
assert_template('test/_labelling_form')
assert_equal "<label for=\"post_title\">Title</label>\n", @response.body
end
def test_nested_partial_with_form_builder
@controller = Fun::GamesController.new
get :nested_partial_with_form_builder
assert_match(/<label/, @response.body)
assert_template('fun/games/_form')
assert_equal "<label for=\"post_title\">Title</label>\n", @response.body
end
def test_namespaced_object_partial
@ -1286,48 +1279,29 @@ class RenderTest < ActionController::TestCase
assert_equal "Bonjour: davidBonjour: mary", @response.body
end
def test_locals_option_to_assert_template_is_not_supported
get :partial_collection_with_locals
warning_buffer = StringIO.new
$stderr = warning_buffer
assert_template partial: 'customer_greeting', locals: { greeting: 'Bonjour' }
assert_equal "the :locals option to #assert_template is only supported in a ActionView::TestCase\n", warning_buffer.string
ensure
$stderr = STDERR
end
def test_partial_collection_with_spacer
get :partial_collection_with_spacer
assert_equal "Hello: davidonly partialHello: mary", @response.body
assert_template :partial => '_customer'
end
def test_partial_collection_with_spacer_which_uses_render
get :partial_collection_with_spacer_which_uses_render
assert_equal "Hello: davidpartial html\npartial with partial\nHello: mary", @response.body
assert_template :partial => '_customer'
end
def test_partial_collection_shorthand_with_locals
get :partial_collection_shorthand_with_locals
assert_equal "Bonjour: davidBonjour: mary", @response.body
assert_template :partial => 'customers/_customer', :count => 2
assert_template :partial => '_completely_fake_and_made_up_template_that_cannot_possibly_be_rendered', :count => 0
end
def test_partial_collection_shorthand_with_different_types_of_records
get :partial_collection_shorthand_with_different_types_of_records
assert_equal "Bonjour bad customer: mark0Bonjour good customer: craig1Bonjour bad customer: john2Bonjour good customer: zach3Bonjour good customer: brandon4Bonjour bad customer: dan5", @response.body
assert_template :partial => 'good_customers/_good_customer', :count => 3
assert_template :partial => 'bad_customers/_bad_customer', :count => 3
end
def test_empty_partial_collection
get :empty_partial_collection
assert_equal " ", @response.body
assert_template :partial => false
end
def test_partial_with_hash_object

18
actionview/test/activerecord/render_partial_with_record_identification_test.rb
View file

@ -52,43 +52,37 @@ class RenderPartialWithRecordIdentificationTest < ActiveRecordTestCase
def test_rendering_partial_with_has_many_and_belongs_to_association
get :render_with_has_many_and_belongs_to_association
assert_template 'projects/_project'
assert_equal assigns(:developer).projects.map(&:name).join, @response.body
assert_equal Developer.find(1).projects.map(&:name).join, @response.body
end
def test_rendering_partial_with_has_many_association
get :render_with_has_many_association
assert_template 'replies/_reply'
assert_equal 'Birdman is better!', @response.body
end
def test_rendering_partial_with_scope
get :render_with_scope
assert_template 'replies/_reply'
assert_equal 'Birdman is better!Nuh uh!', @response.body
end
def test_render_with_record
get :render_with_record
assert_template 'developers/_developer'
assert_equal 'David', @response.body
end
def test_render_with_record_collection
get :render_with_record_collection
assert_template 'developers/_developer'
assert_equal 'DavidJamisfixture_3fixture_4fixture_5fixture_6fixture_7fixture_8fixture_9fixture_10Jamis', @response.body
end
def test_render_with_record_collection_and_spacer_template
get :render_with_record_collection_and_spacer_template
assert_equal assigns(:developer).projects.map(&:name).join('only partial'), @response.body
assert_equal Developer.find(1).projects.map(&:name).join('only partial'), @response.body
end
def test_rendering_partial_with_has_one_association
mascot = Company.find(1).mascot
get :render_with_has_one_association
assert_template 'mascots/_mascot'
assert_equal mascot.name, @response.body
end
end
@ -130,13 +124,11 @@ class RenderPartialWithRecordIdentificationAndNestedControllersTest < ActiveReco
def test_render_with_record_in_nested_controller
get :render_with_record_in_nested_controller
assert_template %r{\Afun/games/_game\Z}
assert_equal "Fun Pong\n", @response.body
end
def test_render_with_record_collection_in_nested_controller
get :render_with_record_collection_in_nested_controller
assert_template %r{\Afun/games/_game\Z}
assert_equal "Fun Pong\nFun Tank\n", @response.body
end
end
@ -149,7 +141,6 @@ class RenderPartialWithRecordIdentificationAndNestedControllersWithoutPrefixTest
ActionView::Base.prefix_partial_path_with_controller_namespace = false
get :render_with_record_in_nested_controller
assert_template %r{\Agames/_game\Z}
assert_equal "Just Pong\n", @response.body
ensure
ActionView::Base.prefix_partial_path_with_controller_namespace = old_config
@ -160,7 +151,6 @@ class RenderPartialWithRecordIdentificationAndNestedControllersWithoutPrefixTest
ActionView::Base.prefix_partial_path_with_controller_namespace = false
get :render_with_record_collection_in_nested_controller
assert_template %r{\Agames/_game\Z}
assert_equal "Just Pong\nJust Tank\n", @response.body
ensure
ActionView::Base.prefix_partial_path_with_controller_namespace = old_config
@ -172,13 +162,11 @@ class RenderPartialWithRecordIdentificationAndNestedDeeperControllersTest < Acti
def test_render_with_record_in_deeper_nested_controller
get :render_with_record_in_deeper_nested_controller
assert_template %r{\Afun/serious/games/_game\Z}
assert_equal "Serious Chess\n", @response.body
end
def test_render_with_record_collection_in_deeper_nested_controller
get :render_with_record_collection_in_deeper_nested_controller
assert_template %r{\Afun/serious/games/_game\Z}
assert_equal "Serious Chess\nSerious Sudoku\nSerious Solitaire\n", @response.body
end
end
@ -191,7 +179,6 @@ class RenderPartialWithRecordIdentificationAndNestedDeeperControllersWithoutPref
ActionView::Base.prefix_partial_path_with_controller_namespace = false
get :render_with_record_in_deeper_nested_controller
assert_template %r{\Agames/_game\Z}
assert_equal "Just Chess\n", @response.body
ensure
ActionView::Base.prefix_partial_path_with_controller_namespace = old_config
@ -202,7 +189,6 @@ class RenderPartialWithRecordIdentificationAndNestedDeeperControllersWithoutPref
ActionView::Base.prefix_partial_path_with_controller_namespace = false
get :render_with_record_collection_in_deeper_nested_controller
assert_template %r{\Agames/_game\Z}
assert_equal "Just Chess\nJust Sudoku\nJust Solitaire\n", @response.body
ensure
ActionView::Base.prefix_partial_path_with_controller_namespace = old_config

1
actionview/test/fixtures/actionpack/layout_tests/alt/layouts/alt.erb vendored
View file

@ -0,0 +1 @@
alt.erb

2
actionview/test/fixtures/actionpack/test/hyphen-ated.erb vendored
View file

@ -1 +1 @@
Hello world!
hyphen-ated.erb

58
actionview/test/template/test_case_test.rb
View file

@ -306,64 +306,6 @@ module ActionView
end
end
class RenderTemplateTest < ActionView::TestCase
test "supports specifying templates with a Regexp" do
controller.controller_path = "fun"
render(:template => "fun/games/hello_world")
assert_template %r{\Afun/games/hello_world\Z}
end
test "supports specifying partials" do
controller.controller_path = "test"
render(:template => "test/calling_partial_with_layout")
assert_template :partial => "_partial_for_use_in_layout"
end
test "supports specifying locals (passing)" do
controller.controller_path = "test"
render(:template => "test/calling_partial_with_layout")
assert_template :partial => "_partial_for_use_in_layout", :locals => { :name => "David" }
end
test "supports specifying locals (failing)" do
controller.controller_path = "test"
render(:template => "test/calling_partial_with_layout")
e = assert_raise ActiveSupport::TestCase::Assertion do
assert_template :partial => "_partial_for_use_in_layout", :locals => { :name => "Somebody Else" }
end
assert_match(/Somebody Else.*David/m, e.message)
end
test 'supports different locals on the same partial' do
controller.controller_path = "test"
render(:template => "test/render_two_partials")
assert_template partial: '_partial', locals: { 'first' => '1' }
assert_template partial: '_partial', locals: { 'second' => '2' }
end
test 'raises descriptive error message when template was not rendered' do
controller.controller_path = "test"
render(template: "test/hello_world_with_partial")
e = assert_raise ActiveSupport::TestCase::Assertion do
assert_template partial: 'i_was_never_rendered', locals: { 'did_not' => 'happen' }
end
assert_match "i_was_never_rendered to be rendered but it was not.", e.message
assert_match 'Expected ["/test/partial"] to include "i_was_never_rendered"', e.message
end
test 'specifying locals works when the partial is inside a directory with underline prefix' do
controller.controller_path = "test"
render(template: 'test/render_partial_inside_directory')
assert_template partial: 'test/_directory/_partial_with_locales', locals: { 'name' => 'Jane' }
end
test 'specifying locals works when the partial is inside a directory without underline prefix' do
controller.controller_path = "test"
render(template: 'test/render_partial_inside_directory')
assert_template partial: 'test/_directory/partial_with_locales', locals: { 'name' => 'Jane' }
end
end
module AHelperWithInitialize
def initialize(*)
super

2
activesupport/lib/active_support/testing/assertions.rb
View file

@ -28,7 +28,7 @@ module ActiveSupport
#
# An arbitrary expression is passed in and evaluated.
#
# assert_difference 'assigns(:article).comments(:reload).size' do
# assert_difference 'Article.last.comments(:reload).size' do
# post :create, params: { comment: {...} }
# end
#

70
guides/source/testing.md
View file

@ -467,7 +467,6 @@ Rails adds some custom assertions of its own to the `minitest` framework:
| `assert_generates(expected_path, options, defaults={}, extras = {}, message=nil)` | Asserts that the provided options can be used to generate the provided path. This is the inverse of assert_recognizes. The extras parameter is used to tell the request the names and values of additional request parameters that would be in a query string. The message parameter allows you to specify a custom error message for assertion failures.|
| `assert_response(type, message = nil)` | Asserts that the response comes with a specific status code. You can specify `:success` to indicate 200-299, `:redirect` to indicate 300-399, `:missing` to indicate 404, or `:error` to match the 500-599 range. You can also pass an explicit status number or its symbolic equivalent. For more information, see [full list of status codes](http://rubydoc.info/github/rack/rack/master/Rack/Utils#HTTP_STATUS_CODES-constant) and how their [mapping](http://rubydoc.info/github/rack/rack/master/Rack/Utils#SYMBOL_TO_STATUS_CODE-constant) works.|
| `assert_redirected_to(options = {}, message=nil)` | Assert that the redirection options passed in match those of the redirect called in the latest action. This match can be partial, such that `assert_redirected_to(controller: "weblog")` will also match the redirection of `redirect_to(controller: "weblog", action: "show")` and so on. You can also pass named routes such as `assert_redirected_to root_path` and Active Record objects such as `assert_redirected_to @article`.|
| `assert_template(expected = nil, message=nil)` | Asserts that the request was rendered with the appropriate template file.|
You'll see the usage of some of these assertions in the next chapter.
@ -506,16 +505,18 @@ Now that we have used Rails scaffold generator for our `Article` resource, it ha
Let me take you through one such test, `test_should_get_index` from the file `articles_controller_test.rb`.
```ruby
# articles_controller_test.rb
class ArticlesControllerTest < ActionController::TestCase
test "should get index" do
get :index
assert_response :success
assert_not_nil assigns(:articles)
assert_includes @response.body, 'Articles'
end
end
```
In the `test_should_get_index` test, Rails simulates a request on the action called `index`, making sure the request was successful and also ensuring that it assigns a valid `articles` instance variable.
In the `test_should_get_index` test, Rails simulates a request on the action called `index`, making sure the request was successful
and also ensuring that the right response body has been generated.
The `get` method kicks off the web request and populates the results into the response. It accepts 4 arguments:
@ -553,7 +554,7 @@ test "should create article" do
post :create, params: { article: { title: 'Some title' } }
end
assert_redirected_to article_path(assigns(:article))
assert_redirected_to article_path(Article.last)
end
```
@ -580,11 +581,11 @@ To test AJAX requests, you can specify the `xhr: true` option to `get`, `post`,
`patch`, `put`, and `delete` methods:
```ruby
test "ajax request responds with no layout" do
test "ajax request" do
get :show, params: { id: articles(:first).id }, xhr: true
assert_template :index
assert_template layout: nil
assert_equal 'hello world', @response.body
assert_equal "text/javascript", @response.content_type
end
```
@ -592,20 +593,16 @@ end
After a request has been made and processed, you will have 4 Hash objects ready for use:
* `assigns` - Any objects that are stored as instance variables in actions for use in views.
* `cookies` - Any cookies that are set.
* `flash` - Any objects living in the flash.
* `session` - Any object living in session variables.
As is the case with normal Hash objects, you can access the values by referencing the keys by string. You can also reference them by symbol name, except for `assigns`. For example:
As is the case with normal Hash objects, you can access the values by referencing the keys by string. You can also reference them by symbol name. For example:
```ruby
flash["gordon"] flash[:gordon]
session["shmession"] session[:shmession]
cookies["are_good_for_u"] cookies[:are_good_for_u]
# Because you can't use assigns[:something] for historical reasons:
assigns["something"] assigns(:something)
```
### Instance Variables Available
@ -633,46 +630,6 @@ get :index # simulate the request with custom header
post :create # simulate the request with custom env variable
```
### Testing Templates and Layouts
Eventually, you may want to test whether a specific layout is rendered in the view of a response.
#### Asserting Templates
If you want to make sure that the response rendered the correct template and layout, you can use the `assert_template`
method:
```ruby
test "index should render correct template and layout" do
get :index
assert_template :index
assert_template layout: "layouts/application"
# You can also pass a regular expression.
assert_template layout: /layouts\/application/
end
```
NOTE: You cannot test for template and layout at the same time, with a single call to `assert_template`.
WARNING: You must include the "layouts" directory name even if you save your layout file in this standard layout directory. Hence, `assert_template layout: "application"` will not work.
#### Asserting Partials
If your view renders any partial, when asserting for the layout, you can to assert for the partial at the same time.
Otherwise, assertion will fail.
Remember, we added the "_form" partial to our new Article view? Let's write an assertion for that in the `:new` action now:
```ruby
test "new should render correct layout" do
get :new
assert_template layout: "layouts/application", partial: "_form"
end
```
This is the correct way to assert for when the view renders a partial with a given name. As identified by the `:partial` key passed to the `assert_template` call.
### Testing `flash` notices
If you remember from earlier one of the Four Hashes of the Apocalypse was `flash`.
@ -688,7 +645,7 @@ test "should create article" do
post :create, params: { article: { title: 'Some title' } }
end
assert_redirected_to article_path(assigns(:article))
assert_redirected_to article_path(Article.last)
assert_equal 'Article was successfully created.', flash[:notice]
end
```
@ -781,7 +738,7 @@ We can also add a test for updating an existing Article.
test "should update article" do
article = articles(:one)
patch :update, params: { id: article.id, article: { title: "updated" } }
assert_redirected_to article_path(assigns(:article))
assert_redirected_to article_path(article)
end
```
@ -820,7 +777,7 @@ class ArticlesControllerTest < ActionController::TestCase
test "should update article" do
patch :update, params: { id: @article.id, article: { title: "updated" } }
assert_redirected_to article_path(assigns(:article))
assert_redirected_to article_path(@article)
end
end
```
@ -857,7 +814,6 @@ class ProfileControllerTest < ActionController::TestCase
get :show
assert_response :success
assert_equal users(:david), assigns(:user)
end
end
```
@ -1071,14 +1027,12 @@ How about testing our ability to create a new article in our blog and see the re
test "can create an article" do
get "/articles/new"
assert_response :success
assert_template "articles/new", partial: "articles/_form"
post "/articles",
params: { article: { title: "can create", body: "article successfully." } }
assert_response :redirect
follow_redirect!
assert_response :success
assert_template "articles/show"
assert_select "p", "Title:\n can create"
end
```

2
railties/test/application/test_test.rb
View file

@ -44,7 +44,7 @@ module ApplicationTests
def test_index
get '/posts'
assert_response :success
assert_template "index"
assert_includes @response.body, 'Posts#index'
end
end
RUBY