actionpack 1.13.6 → 2.0.0

data/test/controller/fake_models.rb

@@ -0,0 +1,5 @@
+class Customer < Struct.new(:name, :id)
+  def to_param
+    id.to_s
+  end
+end

data/test/controller/filters_test.rb

@@ -44,7 +44,9 @@ class FilterTest < Test::Unit::TestCase
     (1..3).each do |i|
       define_method "try_#{i}" do
         instance_variable_set :@try, i
-        action_name != "fail_#{i}"
+        if action_name == "fail_#{i}"
+          head(404)
+        end
       end
     end
   end
@@ -234,7 +236,7 @@ class FilterTest < Test::Unit::TestCase
     before_filter(AuditFilter)
 
     def show
-      render_text "hello"
+      render :text => "hello"
     end
   end
 
@@ -271,11 +273,11 @@ class FilterTest < Test::Unit::TestCase
     before_filter :second, :only => :foo
 
     def foo
-      render_text 'foo'
+      render :text => 'foo'
     end
 
     def bar
-      render_text 'bar'
+      render :text => 'bar'
     end
 
     protected
@@ -325,6 +327,31 @@ class FilterTest < Test::Unit::TestCase
     end
   end
 
+  class ErrorToRescue < Exception; end
+
+  class RescuingAroundFilterWithBlock
+    def filter(controller)
+      begin
+        yield
+      rescue ErrorToRescue => ex
+        controller.send! :render, :text => "I rescued this: #{ex.inspect}"
+      end
+    end
+  end
+
+  class RescuedController < ActionController::Base
+    around_filter RescuingAroundFilterWithBlock.new
+
+    def show
+      raise ErrorToRescue.new("Something made the bad noise.")
+    end
+
+  private
+    def rescue_action(exception)
+      raise exception
+    end
+  end
+
   class NonYieldingAroundFilterController < ActionController::Base
 
     before_filter :filter_one
@@ -558,6 +585,16 @@ class FilterTest < Test::Unit::TestCase
     assert_equal nil, test_process(ChangingTheRequirementsController, "go_wild").template.assigns['ran_filter']
   end
 
+  def test_a_rescuing_around_filter
+    response = nil
+    assert_nothing_raised do
+      response = test_process(RescuedController)
+    end
+
+    assert response.success?
+    assert_equal("I rescued this: #<FilterTest::ErrorToRescue: Something made the bad noise.>", response.body)
+  end
+
   private
     def test_process(controller, action = "show")
       request = ActionController::TestRequest.new
@@ -788,7 +825,7 @@ class YieldingAroundFiltersTest < Test::Unit::TestCase
   def test_first_filter_in_multiple_before_filter_chain_halts
     controller = ::FilterTest::TestMultipleFiltersController.new
     response = test_process(controller, 'fail_1')
-    assert_equal '', response.body
+    assert_equal ' ', response.body
     assert_equal 1, controller.instance_variable_get(:@try)
     assert controller.instance_variable_get(:@before_filter_chain_aborted)
   end
@@ -796,7 +833,7 @@ class YieldingAroundFiltersTest < Test::Unit::TestCase
   def test_second_filter_in_multiple_before_filter_chain_halts
     controller = ::FilterTest::TestMultipleFiltersController.new
     response = test_process(controller, 'fail_2')
-    assert_equal '', response.body
+    assert_equal ' ', response.body
     assert_equal 2, controller.instance_variable_get(:@try)
     assert controller.instance_variable_get(:@before_filter_chain_aborted)
   end
@@ -804,7 +841,7 @@ class YieldingAroundFiltersTest < Test::Unit::TestCase
   def test_last_filter_in_multiple_before_filter_chain_halts
     controller = ::FilterTest::TestMultipleFiltersController.new
     response = test_process(controller, 'fail_3')
-    assert_equal '', response.body
+    assert_equal ' ', response.body
     assert_equal 3, controller.instance_variable_get(:@try)
     assert controller.instance_variable_get(:@before_filter_chain_aborted)
   end

data/test/controller/flash_test.rb

@@ -31,7 +31,13 @@ class FlashTest < Test::Unit::TestCase
     def use_flash_and_keep_it
       @flash_copy = {}.update flash
       @flashy = flash["that"]
-      silence_warnings { keep_flash }
+      flash.keep
+      render :inline => "hello"
+    end
+    
+    def use_flash_and_update_it
+      flash.update("this" => "hello again")
+      @flash_copy = {}.update flash
       render :inline => "hello"
     end
 
@@ -48,6 +54,23 @@ class FlashTest < Test::Unit::TestCase
     def rescue_action(e)
       raise unless ActionController::MissingTemplate === e
     end
+
+    # methods for test_sweep_after_halted_filter_chain
+    before_filter :halt_and_redir, :only => "filter_halting_action"
+
+    def std_action
+      @flash_copy = {}.update(flash)
+    end
+
+    def filter_halting_action
+      @flash_copy = {}.update(flash)
+    end
+
+    def halt_and_redir
+      flash["foo"] = "bar"
+      redirect_to :action => "std_action"
+      @flash_copy = {}.update(flash)
+    end
   end
 
   def setup
@@ -70,7 +93,7 @@ class FlashTest < Test::Unit::TestCase
   def test_keep_flash
     get :set_flash
     
-    assert_deprecated(/keep_flash/) { get :use_flash_and_keep_it }
+    get :use_flash_and_keep_it
     assert_equal "hello", @response.template.assigns["flash_copy"]["that"]
     assert_equal "hello", @response.template.assigns["flashy"]
 
@@ -93,10 +116,31 @@ class FlashTest < Test::Unit::TestCase
     assert_nil @response.template.assigns["flashy"]
   end 
   
+  def test_update_flash
+    get :set_flash
+    get :use_flash_and_update_it
+    assert_equal "hello",       @response.template.assigns["flash_copy"]["that"]
+    assert_equal "hello again", @response.template.assigns["flash_copy"]["this"]
+    get :use_flash
+    assert_nil                  @response.template.assigns["flash_copy"]["that"], "On second flash"
+    assert_equal "hello again", @response.template.assigns["flash_copy"]["this"], "On second flash"
+  end
+  
   def test_flash_after_reset_session
     get :use_flash_after_reset_session
     assert_equal "hello",    @response.template.assigns["flashy_that"]
     assert_equal "good-bye", @response.template.assigns["flashy_this"]
     assert_nil   @response.template.assigns["flashy_that_reset"]
   end 
+
+  def test_sweep_after_halted_filter_chain
+    get :std_action
+    assert_nil @response.template.assigns["flash_copy"]["foo"]
+    get :filter_halting_action
+    assert_equal "bar", @response.template.assigns["flash_copy"]["foo"]
+    get :std_action # follow redirection
+    assert_equal "bar", @response.template.assigns["flash_copy"]["foo"]
+    get :std_action
+    assert_nil @response.template.assigns["flash_copy"]["foo"]
+  end
 end

data/test/controller/fragment_store_setting_test.rb

@@ -24,14 +24,16 @@ class FragmentCacheStoreSettingTest < Test::Unit::TestCase
     )
     assert_equal "druby://localhost:9192", ActionController::Base.fragment_cache_store.address
   end
-  
-  def test_mem_cache_fragment_cache_store
-    ActionController::Base.fragment_cache_store = :mem_cache_store, "localhost"
-    assert_kind_of(
-      ActionController::Caching::Fragments::MemCacheStore,
-      ActionController::Base.fragment_cache_store
-    )
-    assert_equal %w(localhost), ActionController::Base.fragment_cache_store.addresses
+
+  if defined? CGI::Session::MemCacheStore
+    def test_mem_cache_fragment_cache_store
+      ActionController::Base.fragment_cache_store = :mem_cache_store, "localhost"
+      assert_kind_of(
+        ActionController::Caching::Fragments::MemCacheStore,
+        ActionController::Base.fragment_cache_store
+      )
+      assert_equal %w(localhost), ActionController::Base.fragment_cache_store.addresses
+    end
   end
 
   def test_object_assigned_fragment_cache_store

data/test/controller/helper_test.rb

@@ -1,5 +1,7 @@
 require File.dirname(__FILE__) + '/../abstract_unit'
 
+silence_warnings { ActionController::Helpers::HELPERS_DIR = File.dirname(__FILE__) + '/../fixtures/helpers' }
+
 class TestController < ActionController::Base
   attr_accessor :delegate_attr
   def delegate_method() end
@@ -15,7 +17,7 @@ module Fun
     def rescue_action(e) raise end
   end
 
-  class PDFController < ActionController::Base
+  class PdfController < ActionController::Base
     def test
       render :inline => "test: <%= foobar %>"
     end
@@ -24,6 +26,10 @@ module Fun
   end
 end
 
+class ApplicationController < ActionController::Base
+  helper :all
+end
+
 module LocalAbcHelper
   def a() end
   def b() end
@@ -120,7 +126,18 @@ class HelperTest < Test::Unit::TestCase
     response = ActionController::TestResponse.new
     request.action = 'test'
 
-    assert_equal 'test: baz', Fun::PDFController.process(request, response).body
+    assert_equal 'test: baz', Fun::PdfController.process(request, response).body
+  end
+
+  def test_all_helpers
+    # abc_helper.rb
+    assert ApplicationController.master_helper_module.instance_methods.include?("bare_a")
+
+    # fun/games_helper.rb
+    assert ApplicationController.master_helper_module.instance_methods.include?("stratego")
+
+    # fun/pdf_helper.rb
+    assert ApplicationController.master_helper_module.instance_methods.include?("foobar")
   end
 
   private

data/test/controller/html-scanner/document_test.rb

@@ -0,0 +1,124 @@
+require File.dirname(__FILE__) + '/../../abstract_unit'
+require 'test/unit'
+
+class DocumentTest < Test::Unit::TestCase
+  def test_handle_doctype
+    doc = nil
+    assert_nothing_raised do
+      doc = HTML::Document.new <<-HTML.strip
+        <!DOCTYPE "blah" "blah" "blah">
+        <html>
+        </html>
+      HTML
+    end
+    assert_equal 3, doc.root.children.length
+    assert_equal %{<!DOCTYPE "blah" "blah" "blah">}, doc.root.children[0].content
+    assert_match %r{\s+}m, doc.root.children[1].content
+    assert_equal "html", doc.root.children[2].name
+  end
+  
+  def test_find_img
+    doc = HTML::Document.new <<-HTML.strip
+      <html>
+        <body>
+          <p><img src="hello.gif"></p>
+        </body>
+      </html>
+    HTML
+    assert doc.find(:tag=>"img", :attributes=>{"src"=>"hello.gif"})
+  end
+
+  def test_find_all
+    doc = HTML::Document.new <<-HTML.strip
+      <html>
+        <body>
+          <p class="test"><img src="hello.gif"></p>
+          <div class="foo">
+            <p class="test">something</p>
+            <p>here is <em class="test">more</em></p>
+          </div>
+        </body>
+      </html>
+    HTML
+    all = doc.find_all :attributes => { :class => "test" }
+    assert_equal 3, all.length
+    assert_equal [ "p", "p", "em" ], all.map { |n| n.name }
+  end
+
+  def test_find_with_text
+    doc = HTML::Document.new <<-HTML.strip
+      <html>
+        <body>
+          <p>Some text</p>
+        </body>
+      </html>
+    HTML
+    assert doc.find(:content => "Some text")
+    assert doc.find(:tag => "p", :child => { :content => "Some text" })
+    assert doc.find(:tag => "p", :child => "Some text")
+    assert doc.find(:tag => "p", :content => "Some text")
+  end
+
+  def test_parse_xml
+    assert_nothing_raised { HTML::Document.new("<tags><tag/></tags>", true, true) }
+    assert_nothing_raised { HTML::Document.new("<outer><link>something</link></outer>", true, true) }
+  end
+
+  def test_parse_document
+    doc = HTML::Document.new(<<-HTML)
+      <div>
+        <h2>blah</h2>
+        <table>
+        </table>
+      </div>
+    HTML
+    assert_not_nil doc.find(:tag => "div", :children => { :count => 1, :only => { :tag => "table" } })
+  end
+
+  def test_tag_nesting_nothing_to_s
+    doc = HTML::Document.new("<tag></tag>")
+    assert_equal "<tag></tag>", doc.root.to_s
+  end
+
+  def test_tag_nesting_space_to_s
+    doc = HTML::Document.new("<tag> </tag>")
+    assert_equal "<tag> </tag>", doc.root.to_s
+  end
+
+  def test_tag_nesting_text_to_s
+    doc = HTML::Document.new("<tag>text</tag>")
+    assert_equal "<tag>text</tag>", doc.root.to_s
+  end
+
+  def test_tag_nesting_tag_to_s
+    doc = HTML::Document.new("<tag><nested /></tag>")
+    assert_equal "<tag><nested /></tag>", doc.root.to_s
+  end
+
+  def test_parse_cdata
+    doc = HTML::Document.new(<<-HTML)
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+  <head>
+    <title><![CDATA[<br>]]></title>
+   </head>
+  <body>
+    <p>this document has &lt;br&gt; for a title</p>
+  </body>
+</html>
+HTML
+
+    assert_nil doc.find(:tag => "title", :descendant => { :tag => "br" })
+    assert doc.find(:tag => "title", :child => "<br>")
+  end
+
+  def test_find_empty_tag
+    doc = HTML::Document.new("<div id='map'></div>")
+    assert_nil doc.find(:tag => "div", :attributes => { :id => "map" }, :content => /./)
+    assert doc.find(:tag => "div", :attributes => { :id => "map" }, :content => /\A\Z/)
+    assert doc.find(:tag => "div", :attributes => { :id => "map" }, :content => /^$/)
+    assert doc.find(:tag => "div", :attributes => { :id => "map" }, :content => "")
+    assert doc.find(:tag => "div", :attributes => { :id => "map" }, :content => nil)
+  end
+end

data/test/controller/html-scanner/node_test.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../../abstract_unit'
+require 'test/unit'
+
+class NodeTest < Test::Unit::TestCase
+  
+  class MockNode
+    def initialize(matched, value)
+      @matched = matched
+      @value = value
+    end
+    
+    def find(conditions)
+      @matched && self
+    end
+    
+    def to_s
+      @value.to_s
+    end
+  end
+  
+  def setup
+    @node = HTML::Node.new("parent")
+    @node.children.concat [MockNode.new(false,1), MockNode.new(true,"two"), MockNode.new(false,:three)]
+  end
+  
+  def test_match
+    assert !@node.match("foo")
+  end
+  
+  def test_tag
+    assert !@node.tag?
+  end
+  
+  def test_to_s
+    assert_equal "1twothree", @node.to_s
+  end
+  
+  def test_find
+    assert_equal "two", @node.find('blah').to_s
+  end
+
+  def test_parse_strict
+    s = "<b foo='hello'' bar='baz'>"
+    assert_raise(RuntimeError) { HTML::Node.parse(nil,0,0,s) }
+  end
+
+  def test_parse_relaxed
+    s = "<b foo='hello'' bar='baz'>"
+    node = nil
+    assert_nothing_raised { node = HTML::Node.parse(nil,0,0,s,false) }
+    assert node.attributes.has_key?("foo")
+    assert !node.attributes.has_key?("bar")
+  end
+
+  def test_to_s_with_boolean_attrs
+    s = "<b foo bar>"
+    node = HTML::Node.parse(nil,0,0,s)
+    assert node.attributes.has_key?("foo")
+    assert node.attributes.has_key?("bar")
+    assert "<b foo bar>", node.to_s
+  end
+  
+  def test_parse_with_unclosed_tag
+    s = "<span onmouseover='bang'"
+    node = nil
+    assert_nothing_raised { node = HTML::Node.parse(nil,0,0,s,false) }
+    assert node.attributes.has_key?("onmouseover")
+  end
+end