actionpack 2.3.18 → 3.0.0.beta

data/test/template/atom_feed_helper_test.rb

@@ -1,315 +0,0 @@
-require 'abstract_unit'
-
-Scroll = Struct.new(:id, :to_param, :title, :body, :updated_at, :created_at)
-
-class ScrollsController < ActionController::Base
-  FEEDS = {}
-  FEEDS["defaults"] = <<-EOT
-        atom_feed(:schema_date => '2008') do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          for scroll in @scrolls
-            feed.entry(scroll) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-    FEEDS["entry_options"] = <<-EOT
-        atom_feed do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          for scroll in @scrolls
-            feed.entry(scroll, :url => "/otherstuff/" + scroll.to_param, :updated => Time.utc(2007, 1, scroll.id)) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-    FEEDS["xml_block"] = <<-EOT
-        atom_feed do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          feed.author do |author|
-            author.name("DHH")
-          end
-
-          for scroll in @scrolls
-            feed.entry(scroll, :url => "/otherstuff/" + scroll.to_param, :updated => Time.utc(2007, 1, scroll.id)) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-            end
-          end
-        end
-    EOT
-    FEEDS["feed_with_atomPub_namespace"] = <<-EOT
-        atom_feed({'xmlns:app' => 'http://www.w3.org/2007/app',
-                 'xmlns:openSearch' => 'http://a9.com/-/spec/opensearch/1.1/'}) do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          for scroll in @scrolls
-            feed.entry(scroll) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-              entry.tag!('app:edited', Time.now)
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-    FEEDS["feed_with_overridden_ids"] = <<-EOT
-        atom_feed({:id => 'tag:test.rubyonrails.org,2008:test/'}) do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          for scroll in @scrolls
-            feed.entry(scroll, :id => "tag:test.rubyonrails.org,2008:"+scroll.id.to_s) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-              entry.tag!('app:edited', Time.now)
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-  FEEDS["feed_with_xml_processing_instructions"] = <<-EOT
-        atom_feed(:schema_date => '2008',
-          :instruct => {'xml-stylesheet' => { :href=> 't.css', :type => 'text/css' }}) do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          for scroll in @scrolls
-            feed.entry(scroll) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-  FEEDS["feed_with_xml_processing_instructions_duplicate_targets"] = <<-EOT
-        atom_feed(:schema_date => '2008',
-          :instruct => {'target1' => [{ :a => '1', :b => '2' }, { :c => '3', :d => '4' }]}) do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          for scroll in @scrolls
-            feed.entry(scroll) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-    FEEDS["feed_with_xhtml_content"] = <<-'EOT'
-        atom_feed do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          for scroll in @scrolls
-            feed.entry(scroll) do |entry|
-              entry.title(scroll.title)
-              entry.summary(:type => 'xhtml') do |xhtml|
-                xhtml.p "before #{scroll.id}"
-                xhtml.p {xhtml << scroll.body}
-                xhtml.p "after #{scroll.id}"
-              end
-              entry.tag!('app:edited', Time.now)
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-    FEEDS["provide_builder"] = <<-'EOT'
-          # we pass in the new_xml to the helper so it doesn't
-          # call anything on the original builder
-          new_xml = Builder::XmlMarkup.new(:target=>'')
-          atom_feed(:xml => new_xml) do |feed|
-            feed.title("My great blog!")
-            feed.updated((@scrolls.first.created_at))
-
-            for scroll in @scrolls
-              feed.entry(scroll) do |entry|
-                entry.title(scroll.title)
-                entry.content(scroll.body, :type => 'html')
-
-                entry.author do |author|
-                  author.name("DHH")
-                end
-              end
-            end
-          end
-    EOT
-  def index
-    @scrolls = [
-      Scroll.new(1, "1", "Hello One", "Something <i>COOL!</i>", Time.utc(2007, 12, 12, 15), Time.utc(2007, 12, 12, 15)),
-      Scroll.new(2, "2", "Hello Two", "Something Boring", Time.utc(2007, 12, 12, 15)),
-    ]
-
-    render :inline => FEEDS[params[:id]], :type => :builder
-  end
-
-  protected
-
-  def rescue_action(e)
-    raise(e)
-  end
-end
-
-class AtomFeedTest < ActionController::TestCase
-  tests ScrollsController
-
-  def setup
-    @request.host = "www.nextangle.com"
-  end
-
-  def test_feed_should_use_default_language_if_none_is_given
-    with_restful_routing(:scrolls) do
-      get :index, :id => "defaults"
-      assert_match %r{xml:lang="en-US"}, @response.body
-    end
-  end
-
-  def test_feed_should_include_two_entries
-    with_restful_routing(:scrolls) do
-      get :index, :id => "defaults"
-      assert_select "entry", 2
-    end
-  end
-
-  def test_entry_should_only_use_published_if_created_at_is_present
-    with_restful_routing(:scrolls) do
-      get :index, :id => "defaults"
-      assert_select "published", 1
-    end
-  end
-
-  def test_providing_builder_to_atom_feed
-    with_restful_routing(:scrolls) do
-      get :index, :id=>"provide_builder"
-      # because we pass in the non-default builder, the content generated by the
-      # helper should go 'nowhere'.  Leaving the response body blank.
-      assert @response.body.blank?
-    end
-  end
-
-  def test_entry_with_prefilled_options_should_use_those_instead_of_querying_the_record
-    with_restful_routing(:scrolls) do
-      get :index, :id => "entry_options"
-
-      assert_select "updated", Time.utc(2007, 1, 1).xmlschema
-      assert_select "updated", Time.utc(2007, 1, 2).xmlschema
-    end
-  end
-
-  def test_self_url_should_default_to_current_request_url
-    with_restful_routing(:scrolls) do
-      get :index, :id => "defaults"
-      assert_select "link[rel=self][href=http://www.nextangle.com/scrolls?id=defaults]"
-    end
-  end
-
-  def test_feed_id_should_be_a_valid_tag
-    with_restful_routing(:scrolls) do
-      get :index, :id => "defaults"
-      assert_select "id", :text => "tag:www.nextangle.com,2008:/scrolls?id=defaults"
-    end
-  end
-
-  def test_entry_id_should_be_a_valid_tag
-    with_restful_routing(:scrolls) do
-      get :index, :id => "defaults"
-      assert_select "entry id", :text => "tag:www.nextangle.com,2008:Scroll/1"
-      assert_select "entry id", :text => "tag:www.nextangle.com,2008:Scroll/2"
-    end
-  end
-
-  def test_feed_should_allow_nested_xml_blocks
-    with_restful_routing(:scrolls) do
-      get :index, :id => "xml_block"
-      assert_select "author name", :text => "DHH"
-    end
-  end
-
-  def test_feed_should_include_atomPub_namespace
-    with_restful_routing(:scrolls) do
-      get :index, :id => "feed_with_atomPub_namespace"
-      assert_match %r{xml:lang="en-US"}, @response.body
-      assert_match %r{xmlns="http://www.w3.org/2005/Atom"}, @response.body
-      assert_match %r{xmlns:app="http://www.w3.org/2007/app"}, @response.body
-    end
-  end
-
-  def test_feed_should_allow_overriding_ids
-    with_restful_routing(:scrolls) do
-      get :index, :id => "feed_with_overridden_ids"
-      assert_select "id", :text => "tag:test.rubyonrails.org,2008:test/"
-      assert_select "entry id", :text => "tag:test.rubyonrails.org,2008:1"
-      assert_select "entry id", :text => "tag:test.rubyonrails.org,2008:2"
-    end
-  end
-
-  def test_feed_xml_processing_instructions
-    with_restful_routing(:scrolls) do
-      get :index, :id => 'feed_with_xml_processing_instructions'
-      assert_match %r{<\?xml-stylesheet [^\?]*type="text/css"}, @response.body
-      assert_match %r{<\?xml-stylesheet [^\?]*href="t.css"}, @response.body
-    end
-  end
-
-  def test_feed_xml_processing_instructions_duplicate_targets
-    with_restful_routing(:scrolls) do
-      get :index, :id => 'feed_with_xml_processing_instructions_duplicate_targets'
-      assert_match %r{<\?target1 (a="1" b="2"|b="2" a="1")\?>}, @response.body
-      assert_match %r{<\?target1 (c="3" d="4"|d="4" c="3")\?>}, @response.body
-    end
-  end
-
-  def test_feed_xhtml
-    with_restful_routing(:scrolls) do
-      get :index, :id => "feed_with_xhtml_content"
-      assert_match %r{xmlns="http://www.w3.org/1999/xhtml"}, @response.body
-      assert_select "summary div p", :text => "Something Boring"
-      assert_select "summary div p", :text => "after 2"
-    end
-  end
-private
-    def with_restful_routing(resources)
-      with_routing do |set|
-        set.draw do |map|
-          map.resources(resources)
-        end
-        yield
-      end
-    end
-end

data/test/template/benchmark_helper_test.rb

@@ -1,86 +0,0 @@
-require 'abstract_unit'
-require 'action_view/helpers/benchmark_helper'
-
-class BenchmarkHelperTest < ActionView::TestCase
-  tests ActionView::Helpers::BenchmarkHelper
-
-  def setup
-    super
-    controller.logger = ActiveSupport::BufferedLogger.new(StringIO.new)
-    controller.logger.auto_flushing = false
-  end
-
-  def teardown
-    controller.logger.send(:clear_buffer)
-  end
-
-  def test_without_block
-    assert_raise(LocalJumpError) { benchmark }
-    assert buffer.empty?
-  end
-
-  def test_defaults
-    i_was_run = false
-    benchmark { i_was_run = true }
-    assert i_was_run
-    assert_last_logged
-  end
-
-  def test_with_message
-    i_was_run = false
-    benchmark('test_run') { i_was_run = true }
-    assert i_was_run
-    assert_last_logged 'test_run'
-  end
-
-  def test_with_message_and_deprecated_level
-    i_was_run = false
-
-    assert_deprecated do
-      benchmark('debug_run', :debug) { i_was_run = true }
-    end
-
-    assert i_was_run
-    assert_last_logged 'debug_run'
-  end
-
-  def test_within_level
-    controller.logger.level = ActiveSupport::BufferedLogger::DEBUG
-    benchmark('included_debug_run', :level => :debug) { }
-    assert_last_logged 'included_debug_run'
-  end
-
-  def test_outside_level
-    controller.logger.level = ActiveSupport::BufferedLogger::ERROR
-    benchmark('skipped_debug_run', :level => :debug) { }
-    assert_no_match(/skipped_debug_run/, buffer.last)
-  ensure
-    controller.logger.level = ActiveSupport::BufferedLogger::DEBUG
-  end
-
-  def test_without_silencing
-    benchmark('debug_run', :silence => false) do
-      controller.logger.info "not silenced!"
-    end
-
-    assert_equal 2, buffer.size
-  end
-
-  def test_with_silencing
-    benchmark('debug_run', :silence => true) do
-      controller.logger.info "silenced!"
-    end
-
-    assert_equal 1, buffer.size
-  end
-
-
-  private
-    def buffer
-      controller.logger.send(:buffer)
-    end
-  
-    def assert_last_logged(message = 'Benchmarking')
-      assert_match(/^#{message} \(.*\)$/, buffer.last)
-    end
-end

data/test/template/compiled_templates_test.rb

@@ -1,204 +0,0 @@
-require 'abstract_unit'
-require 'controller/fake_models'
-
-class CompiledTemplatesTest < Test::Unit::TestCase
-
-  def setup
-    @explicit_view_paths = nil
-    @compiled_templates = ActionView::Base::CompiledTemplates
-    @compiled_templates.instance_methods.each do |m|
-      @compiled_templates.send(:remove_method, m) if m =~ /^_run_/
-    end
-  end
-
-  def test_template_gets_compiled
-    with_caching(true) do
-      assert_equal 0, @compiled_templates.instance_methods.size
-      assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-      assert_equal 1, @compiled_templates.instance_methods.size
-    end
-  end
-
-  def test_template_gets_recompiled_when_using_different_keys_in_local_assigns
-    with_caching(true) do
-      assert_equal 0, @compiled_templates.instance_methods.size
-      assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-      assert_equal "Hello world!", render(:file => "test/hello_world.erb", :locals => {:foo => "bar"})
-      assert_equal 2, @compiled_templates.instance_methods.size
-    end
-  end
-
-  def test_compiled_template_will_not_be_recompiled_when_rendered_with_identical_local_assigns
-    with_caching(true) do
-      assert_equal 0, @compiled_templates.instance_methods.size
-      assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-      ActionView::Template.any_instance.expects(:compile!).never
-      assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-    end
-  end
-
-  def test_template_changes_are_not_reflected_with_cached_template_loading
-    with_caching(true) do
-      with_reloading(false) do
-        assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-        modify_template "test/hello_world.erb", "Goodbye world!" do
-          assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-        end
-        assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-      end
-    end
-  end
-
-  def test_template_changes_are_reflected_without_cached_template_loading
-    with_caching(true) do
-      with_reloading(true) do
-        assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-        modify_template "test/hello_world.erb", "Goodbye world!" do
-          assert_equal "Goodbye world!", render(:file => "test/hello_world.erb")
-        end
-        assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-      end
-    end
-  end
-
-  def test_template_becomes_missing_if_deleted_without_cached_template_loading
-    with_reloading(true) do
-      assert_equal 'Hello world!', render(:file => 'test/hello_world.erb')
-      delete_template 'test/hello_world.erb' do
-        assert_raise(ActionView::MissingTemplate) { render(:file => 'test/hello_world.erb') }
-      end
-      assert_equal 'Hello world!', render(:file => 'test/hello_world.erb')
-    end
-  end
-
-  def test_swapping_template_handler_is_working_without_cached_template_loading
-    with_reloading(true) do
-      assert_equal 'Hello world!', render(:file => 'test/hello_world')
-      delete_template 'test/hello_world.erb' do
-        rename_template 'test/hello_world_from_rxml.builder', 'test/hello_world.builder' do
-          assert_equal "<html>\n  <p>Hello</p>\n</html>\n", render(:file => 'test/hello_world')
-        end
-      end
-      assert_equal 'Hello world!', render(:file => 'test/hello_world')
-    end
-  end
-
-  def test_adding_localized_template_will_take_precedence_without_cached_template_loading
-    with_reloading(true) do
-      assert_equal 'Hello world!', render(:file => 'test/hello_world')
-      rename_template 'test/hello_world.da.html.erb', 'test/hello_world.en.html.erb' do
-        assert_equal 'Hey verden', render(:file => 'test/hello_world')
-      end
-    end
-  end
-
-  def test_deleting_localized_template_will_fall_back_to_non_localized_template_without_cached_template_loading
-    with_reloading(true) do
-      rename_template 'test/hello_world.da.html.erb', 'test/hello_world.en.html.erb' do
-        assert_equal 'Hey verden', render(:file => 'test/hello_world')
-        delete_template 'test/hello_world.en.html.erb' do
-          assert_equal 'Hello world!', render(:file => 'test/hello_world')
-        end
-        assert_equal 'Hey verden', render(:file => 'test/hello_world')
-      end
-    end
-  end
-
-  def test_parallel_reloadable_view_paths_are_working
-    with_reloading(true) do
-      view_paths_copy = new_reloadable_view_paths
-      assert_equal 'Hello world!', render(:file => 'test/hello_world')
-      with_view_paths(view_paths_copy, new_reloadable_view_paths) do
-        assert_equal 'Hello world!', render(:file => 'test/hello_world')
-      end
-      modify_template 'test/hello_world.erb', 'Goodbye world!' do
-        assert_equal 'Goodbye world!', render(:file => 'test/hello_world')
-        modify_template 'test/hello_world.erb', 'So long, world!' do
-          with_view_paths(view_paths_copy, new_reloadable_view_paths) do
-            assert_equal 'So long, world!', render(:file => 'test/hello_world')
-          end
-          assert_equal 'So long, world!', render(:file => 'test/hello_world')
-        end
-      end
-    end
-  end
-
-  private
-    def render(*args)
-      view_paths = @explicit_view_paths || ActionController::Base.view_paths
-      ActionView::Base.new(view_paths, {}).render(*args)
-    end
-
-    def with_view_paths(*args)
-      args.each do |view_paths|
-        begin
-          @explicit_view_paths = view_paths
-          yield
-        ensure
-          @explicit_view_paths = nil
-        end
-      end
-    end
-
-    def reset_mtime_of(template_name, view_paths_to_use)
-      view_paths_to_use.find_template(template_name).previously_last_modified = 10.seconds.ago unless ActionView::Base.cache_template_loading?
-    end
-
-    def modify_template(template, content, view_paths_to_use = ActionController::Base.view_paths)
-      filename = filename_for(template)
-      old_content = File.read(filename)
-      begin
-        File.open(filename, "wb+") { |f| f.write(content) }
-        reset_mtime_of(template, view_paths_to_use)
-        yield
-      ensure
-        File.open(filename, "wb+") { |f| f.write(old_content) }
-        reset_mtime_of(template, view_paths_to_use)
-      end
-    end
-
-    def filename_for(template)
-      File.join(FIXTURE_LOAD_PATH, template)
-    end
-
-    def rename_template(old_name, new_name)
-      File.rename(filename_for(old_name), filename_for(new_name))
-      yield
-    ensure
-      File.rename(filename_for(new_name), filename_for(old_name))
-    end
-
-    def delete_template(template, &block)
-      rename_template(template, File.join(File.dirname(template), "__#{File.basename(template)}"), &block)
-    end
-
-    def with_caching(perform_caching)
-      old_perform_caching = ActionController::Base.perform_caching
-      begin
-        ActionController::Base.perform_caching = perform_caching
-        yield
-      ensure
-        ActionController::Base.perform_caching = old_perform_caching
-      end
-    end
-
-    def with_reloading(reload_templates, view_paths_owner = ActionController::Base)
-      old_view_paths, old_cache_templates = view_paths_owner.view_paths, ActionView::Base.cache_template_loading
-      begin
-        ActionView::Base.cache_template_loading = !reload_templates
-        view_paths_owner.view_paths = view_paths_for(reload_templates)
-        yield
-      ensure
-        view_paths_owner.view_paths, ActionView::Base.cache_template_loading = old_view_paths, old_cache_templates
-      end
-    end
-
-    def new_reloadable_view_paths
-      ActionView::PathSet.new(CACHED_VIEW_PATHS.map(&:to_s))
-    end
-
-    def view_paths_for(reload_templates)
-      # reloadable paths are cheap to create
-      reload_templates ? new_reloadable_view_paths : CACHED_VIEW_PATHS
-    end
-end