require "#{File.dirname(__FILE__)}/../abstract_unit" require 'action_view/helpers/date_helper' require 'action_view/compiled_templates' class CompiledTemplateTests < Test::Unit::TestCase def setup @ct = ActionView::CompiledTemplates.new @v = Class.new @v.send :include, @ct @a = './test_compile_template_a.rhtml' @b = './test_compile_template_b.rhtml' @s = './test_compile_template_link.rhtml' end def teardown [@a, @b, @s].each do |f| FileUtils.rm(f) if File.exist?(f) || File.symlink?(f) end end attr_reader :ct, :v def test_name_allocation hi_world = ct.method_names['hi world'] hi_sexy = ct.method_names['hi sexy'] wish_upon_a_star = ct.method_names['I love seeing decent error messages'] assert_equal hi_world, ct.method_names['hi world'] assert_equal hi_sexy, ct.method_names['hi sexy'] assert_equal wish_upon_a_star, ct.method_names['I love seeing decent error messages'] assert_equal 3, [hi_world, hi_sexy, wish_upon_a_star].uniq.length end def test_wrap_source assert_equal( "def aliased_assignment(value)\nself.value = value\nend", @ct.wrap_source(:aliased_assignment, [:value], 'self.value = value') ) assert_equal( "def simple()\nnil\nend", @ct.wrap_source(:simple, [], 'nil') ) end def test_compile_source_single_method selector = ct.compile_source('doubling method', [:a], 'a + a') assert_equal 2, @v.new.send(selector, 1) assert_equal 4, @v.new.send(selector, 2) assert_equal -4, @v.new.send(selector, -2) assert_equal 0, @v.new.send(selector, 0) selector end def test_compile_source_two_method sel1 = test_compile_source_single_method # compile the method in the other test sel2 = ct.compile_source('doubling method', [:a, :b], 'a + b + a + b') assert_not_equal sel1, sel2 assert_equal 2, @v.new.send(sel1, 1) assert_equal 4, @v.new.send(sel1, 2) assert_equal 6, @v.new.send(sel2, 1, 2) assert_equal 32, @v.new.send(sel2, 15, 1) end def test_mtime t1 = Time.now test_compile_source_single_method assert (t1..Time.now).include?(ct.mtime('doubling method', [:a])) end uses_mocha 'test_compile_time' do def test_compile_time t = Time.now File.open(@a, "w"){|f| f.puts @a} File.open(@b, "w"){|f| f.puts @b} # windows doesn't support symlinks (even under cygwin) windows = (RUBY_PLATFORM =~ /win32/) `ln -s #{@a} #{@s}` unless windows v = ActionView::Base.new v.base_path = '.' v.cache_template_loading = false # All templates were created at t+1 File::Stat.any_instance.expects(:mtime).times(windows ? 2 : 3).returns(t + 1.second) # private methods template_changed_since? and compile_template? # should report true for all since they have not been compiled assert v.send(:template_changed_since?, @a, t) assert v.send(:template_changed_since?, @b, t) assert v.send(:template_changed_since?, @s, t) unless windows assert v.send(:compile_template?, nil, @a, {}) assert v.send(:compile_template?, nil, @b, {}) assert v.send(:compile_template?, nil, @s, {}) unless windows @handler = ActionView::Base.handler_for_extension(:rhtml) # All templates are rendered at t+2 Time.expects(:now).times(windows ? 2 : 3).returns(t + 2.seconds) v.send(:compile_and_render_template, @handler, '', @a) v.send(:compile_and_render_template, @handler, '', @b) v.send(:compile_and_render_template, @handler, '', @s) unless windows a_n = v.method_names[@a] b_n = v.method_names[@b] s_n = v.method_names[@s] unless windows # all of the files have changed since last compile assert v.compile_time[a_n] > t assert v.compile_time[b_n] > t assert v.compile_time[s_n] > t unless windows # private methods template_changed_since? and compile_template? # should report false for all since none have changed since compile File::Stat.any_instance.expects(:mtime).times(windows ? 6 : 12).returns(t + 1.second) assert !v.send(:template_changed_since?, @a, v.compile_time[a_n]) assert !v.send(:template_changed_since?, @b, v.compile_time[b_n]) assert !v.send(:template_changed_since?, @s, v.compile_time[s_n]) unless windows assert !v.send(:compile_template?, nil, @a, {}) assert !v.send(:compile_template?, nil, @b, {}) assert !v.send(:compile_template?, nil, @s, {}) unless windows v.send(:compile_and_render_template, @handler, '', @a) v.send(:compile_and_render_template, @handler, '', @b) v.send(:compile_and_render_template, @handler, '', @s) unless windows # none of the files have changed since last compile assert v.compile_time[a_n] < t + 3.seconds assert v.compile_time[b_n] < t + 3.seconds assert v.compile_time[s_n] < t + 3.seconds unless windows `rm #{@s}; ln -s #{@b} #{@s}` unless windows # private methods template_changed_since? and compile_template? # should report true for symlink since it has changed since compile # t + 3.seconds is for the symlink File::Stat.any_instance.expects(:mtime).times(windows ? 6 : 9).returns( *(windows ? [ t + 1.second, t + 1.second ] : [ t + 1.second, t + 1.second, t + 3.second ]) * 3) assert !v.send(:template_changed_since?, @a, v.compile_time[a_n]) assert !v.send(:template_changed_since?, @b, v.compile_time[b_n]) assert v.send(:template_changed_since?, @s, v.compile_time[s_n]) unless windows assert !v.send(:compile_template?, nil, @a, {}) assert !v.send(:compile_template?, nil, @b, {}) assert v.send(:compile_template?, nil, @s, {}) unless windows # Only the symlink template gets rendered at t+3 Time.stubs(:now).returns(t + 3.seconds) unless windows v.send(:compile_and_render_template, @handler, '', @a) v.send(:compile_and_render_template, @handler, '', @b) v.send(:compile_and_render_template, @handler, '', @s) unless windows # the symlink has changed since last compile assert v.compile_time[a_n] < t + 3.seconds assert v.compile_time[b_n] < t + 3.seconds assert_equal v.compile_time[s_n], t + 3.seconds unless windows FileUtils.touch @b # private methods template_changed_since? and compile_template? # should report true for symlink and file at end of symlink # since it has changed since last compile # # t+4 is for @b and also for the file that @s points to, which is @b File::Stat.any_instance.expects(:mtime).times(windows ? 6 : 12).returns( *(windows ? [ t + 1.second, t + 4.seconds ] : [ t + 1.second, t + 4.seconds, t + 3.second, t + 4.seconds ]) * 3) assert !v.send(:template_changed_since?, @a, v.compile_time[a_n]) assert v.send(:template_changed_since?, @b, v.compile_time[b_n]) assert v.send(:template_changed_since?, @s, v.compile_time[s_n]) unless windows assert !v.send(:compile_template?, nil, @a, {}) assert v.send(:compile_template?, nil, @b, {}) assert v.send(:compile_template?, nil, @s, {}) unless windows Time.expects(:now).times(windows ? 1 : 2).returns(t + 5.seconds) v.send(:compile_and_render_template, @handler, '', @a) v.send(:compile_and_render_template, @handler, '', @b) v.send(:compile_and_render_template, @handler, '', @s) unless windows # the file at the end of the symlink has changed since last compile # both the symlink and the file at the end of it should be recompiled assert v.compile_time[a_n] < t + 5.seconds assert_equal v.compile_time[b_n], t + 5.seconds assert_equal v.compile_time[s_n], t + 5.seconds unless windows end end end module ActionView class Base def compile_time @@compile_time end def method_names @@method_names end end end