require 'abstract_unit' require 'rails/engine' module ActionView module ATestHelper end module AnotherTestHelper def from_another_helper 'Howdy!' end end module ASharedTestHelper def from_shared_helper 'Holla!' end end class TestCase helper ASharedTestHelper module SharedTests def self.included(test_case) test_case.class_eval do test "helpers defined on ActionView::TestCase are available" do assert test_case.ancestors.include?(ASharedTestHelper) assert_equal 'Holla!', from_shared_helper end end end end end class GeneralViewTest < ActionView::TestCase include SharedTests test_case = self test "memoizes the view" do assert_same view, view end test "exposes view as _view for backwards compatibility" do assert_same _view, view end test "retrieve non existing config values" do assert_equal nil, ActionView::Base.new.config.something_odd end test "works without testing a helper module" do assert_equal 'Eloy', render('developers/developer', :developer => stub(:name => 'Eloy')) end test "can render a layout with block" do assert_equal "Before (ChrisCruft)\n!\nAfter", render(:layout => "test/layout_for_partial", :locals => {:name => "ChrisCruft"}) {"!"} end helper AnotherTestHelper test "additional helper classes can be specified as in a controller" do assert test_case.ancestors.include?(AnotherTestHelper) assert_equal 'Howdy!', from_another_helper end test "determine_default_helper_class returns nil if the test name constant resolves to a class" do assert_nil self.class.determine_default_helper_class("String") end test "delegates notice to request.flash[:notice]" do view.request.flash.expects(:[]).with(:notice) view.notice end test "delegates alert to request.flash[:alert]" do view.request.flash.expects(:[]).with(:alert) view.alert end test "uses controller lookup context" do assert_equal self.lookup_context, @controller.lookup_context end end class ClassMethodsTest < ActionView::TestCase include SharedTests test_case = self tests ATestHelper test "tests the specified helper module" do assert_equal ATestHelper, test_case.helper_class assert test_case.ancestors.include?(ATestHelper) end helper AnotherTestHelper test "additional helper classes can be specified as in a controller" do assert test_case.ancestors.include?(AnotherTestHelper) assert_equal 'Howdy!', from_another_helper test_case.helper_class.module_eval do def render_from_helper from_another_helper end end assert_equal 'Howdy!', render(:partial => 'test/from_helper') end end class HelperInclusionTest < ActionView::TestCase module RenderHelper def render_from_helper render :partial => 'customer', :collection => @customers end end helper RenderHelper test "helper class that is being tested is always included in view instance" do @controller.controller_path = 'test' @customers = [stub(:name => 'Eloy'), stub(:name => 'Manfred')] assert_match(/Hello: EloyHello: Manfred/, render(:partial => 'test/from_helper')) end end class ControllerHelperMethod < ActionView::TestCase module SomeHelper def some_method render :partial => 'test/from_helper' end end helper SomeHelper test "can call a helper method defined on the current controller from a helper" do @controller.singleton_class.class_eval <<-EOF, __FILE__, __LINE__ + 1 def render_from_helper 'controller_helper_method' end EOF @controller.class.helper_method :render_from_helper assert_equal 'controller_helper_method', some_method end end class ViewAssignsTest < ActionView::TestCase test "view_assigns returns a Hash of user defined ivars" do @a = 'b' @c = 'd' assert_equal({:a => 'b', :c => 'd'}, view_assigns) end test "view_assigns excludes internal ivars" do INTERNAL_IVARS.each do |ivar| assert defined?(ivar), "expected #{ivar} to be defined" assert !view_assigns.keys.include?(ivar.to_s.tr('@', '').to_sym), "expected #{ivar} to be excluded from view_assigns" end end end class HelperExposureTest < ActionView::TestCase helper(Module.new do def render_from_helper from_test_case end end) test "is able to make methods available to the view" do assert_equal 'Word!', render(:partial => 'test/from_helper') end def from_test_case; 'Word!'; end helper_method :from_test_case end class IgnoreProtectAgainstForgeryTest < ActionView::TestCase module HelperThatInvokesProtectAgainstForgery def help_me protect_against_forgery? end end helper HelperThatInvokesProtectAgainstForgery test "protect_from_forgery? in any helpers returns false" do assert !view.help_me end end class ATestHelperTest < ActionView::TestCase include SharedTests test_case = self test "inflects the name of the helper module to test from the test case class" do assert_equal ATestHelper, test_case.helper_class assert test_case.ancestors.include?(ATestHelper) end test "a configured test controller is available" do assert_kind_of ActionController::Base, controller assert_equal '', controller.controller_path end test "no additional helpers should shared across test cases" do assert !test_case.ancestors.include?(AnotherTestHelper) assert_raise(NoMethodError) { send :from_another_helper } end test "is able to use routes" do controller.request.assign_parameters(@routes, 'foo', 'index') assert_equal '/foo', url_for assert_equal '/bar', url_for(:controller => 'bar') end test "is able to use named routes" do with_routing do |set| set.draw { resources :contents } assert_equal 'http://test.host/contents/new', new_content_url assert_equal 'http://test.host/contents/1', content_url(:id => 1) end end test "is able to use mounted routes" do with_routing do |set| app = Class.new(Rails::Engine) do def self.routes @routes ||= ActionDispatch::Routing::RouteSet.new end routes.draw { get "bar", :to => lambda {} } def self.call(*) end end set.draw { mount app => "/foo", :as => "foo_app" } assert_equal '/foo/bar', foo_app.bar_path end end test "named routes can be used from helper included in view" do with_routing do |set| set.draw { resources :contents } _helpers.module_eval do def render_from_helper new_content_url end end assert_equal 'http://test.host/contents/new', render(:partial => 'test/from_helper') end end test "is able to render partials with local variables" do assert_equal 'Eloy', render('developers/developer', :developer => stub(:name => 'Eloy')) assert_equal 'Eloy', render(:partial => 'developers/developer', :locals => { :developer => stub(:name => 'Eloy') }) end test "is able to render partials from templates and also use instance variables" do @controller.controller_path = "test" @customers = [stub(:name => 'Eloy'), stub(:name => 'Manfred')] assert_match(/Hello: EloyHello: Manfred/, render(:file => 'test/list')) end test "is able to render partials from templates and also use instance variables after view has been referenced" do @controller.controller_path = "test" view @customers = [stub(:name => 'Eloy'), stub(:name => 'Manfred')] assert_match(/Hello: EloyHello: Manfred/, render(:file => 'test/list')) end end class AssertionsTest < ActionView::TestCase def render_from_helper form_tag('/foo') do safe_concat render(:text => '') end end helper_method :render_from_helper test "uses the output_buffer for assert_select" do render(:partial => 'test/from_helper') assert_select 'form' do assert_select 'li', :text => 'foo' end end test "do not memoize the document_root_element in view tests" do concat form_tag('/foo') assert_select 'form' concat content_tag(:b, 'Strong', class: 'foo') assert_select 'form' assert_select 'b.foo' 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 @called_initialize = true end end class AHelperWithInitializeTest < ActionView::TestCase test "the helper's initialize was actually called" do assert @called_initialize end end end