actionpack 2.1.2 → 2.2.2

data/test/controller/cookie_test.rb

@@ -60,7 +60,7 @@ class CookieTest < Test::Unit::TestCase
   end
 
   def test_setting_cookie_for_fourteen_days_with_symbols
-    get :authenticate_for_fourteen_days
+    get :authenticate_for_fourteen_days_with_symbols
     assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "david", "expires" => Time.local(2005, 10, 10)) ], @response.headers["cookie"]
   end
 

data/test/controller/deprecation/deprecated_base_methods_test.rb

@@ -2,7 +2,6 @@ require 'abstract_unit'
 
 class DeprecatedBaseMethodsTest < Test::Unit::TestCase
   class Target < ActionController::Base
-    
     def home_url(greeting)
       "http://example.com/#{greeting}"
     end
@@ -14,8 +13,6 @@ class DeprecatedBaseMethodsTest < Test::Unit::TestCase
     def rescue_action(e) raise e end
   end
 
-  Target.view_paths = [ File.dirname(__FILE__) + "/../../fixtures" ]
-
   def setup
     @request    = ActionController::TestRequest.new
     @response   = ActionController::TestResponse.new

data/test/controller/dispatcher_test.rb

@@ -26,9 +26,17 @@ class DispatcherTest < Test::Unit::TestCase
   end
 
   def test_clears_dependencies_after_dispatch_if_in_loading_mode
-    ActionController::Routing::Routes.expects(:reload).once
     ActiveSupport::Dependencies.expects(:clear).once
+    dispatch(@output, false)
+  end
+
+  def test_reloads_routes_before_dispatch_if_in_loading_mode
+    ActionController::Routing::Routes.expects(:reload).once
+    dispatch(@output, false)
+  end
 
+  def test_clears_asset_tag_cache_before_dispatch_if_in_loading_mode
+    ActionView::Helpers::AssetTagHelper::AssetTag::Cache.expects(:clear).once
     dispatch(@output, false)
   end
 

data/test/controller/filter_params_test.rb

@@ -27,7 +27,7 @@ class FilterParamTest < Test::Unit::TestCase
 
     test_hashes.each do |before_filter, after_filter, filter_words|
       FilterParamController.filter_parameter_logging(*filter_words)
-      assert_equal after_filter, @controller.send!(:filter_parameters, before_filter)
+      assert_equal after_filter, @controller.__send__(:filter_parameters, before_filter)
 
       filter_words.push('blah')
       FilterParamController.filter_parameter_logging(*filter_words) do |key, value|
@@ -37,7 +37,7 @@ class FilterParamTest < Test::Unit::TestCase
       before_filter['barg'] = {'bargain'=>'gain', 'blah'=>'bar', 'bar'=>{'bargain'=>{'blah'=>'foo'}}}
       after_filter['barg'] = {'bargain'=>'niag', 'blah'=>'[FILTERED]', 'bar'=>{'bargain'=>{'blah'=>'[FILTERED]'}}}
 
-      assert_equal after_filter, @controller.send!(:filter_parameters, before_filter)
+      assert_equal after_filter, @controller.__send__(:filter_parameters, before_filter)
     end
   end
 

data/test/controller/filters_test.rb

@@ -111,15 +111,15 @@ class FilterTest < Test::Unit::TestCase
   end
 
   class OnlyConditionProcController < ConditionalFilterController
-    before_filter(:only => :show) {|c| c.assigns["ran_proc_filter"] = true }
+    before_filter(:only => :show) {|c| c.instance_variable_set(:"@ran_proc_filter", true) }
   end
 
   class ExceptConditionProcController < ConditionalFilterController
-    before_filter(:except => :show_without_filter) {|c| c.assigns["ran_proc_filter"] = true }
+    before_filter(:except => :show_without_filter) {|c| c.instance_variable_set(:"@ran_proc_filter", true) }
   end
 
   class ConditionalClassFilter
-    def self.filter(controller) controller.assigns["ran_class_filter"] = true end
+    def self.filter(controller) controller.instance_variable_set(:"@ran_class_filter", true) end
   end
 
   class OnlyConditionClassController < ConditionalFilterController
@@ -131,7 +131,7 @@ class FilterTest < Test::Unit::TestCase
   end
 
   class AnomolousYetValidConditionController < ConditionalFilterController
-    before_filter(ConditionalClassFilter, :ensure_login, Proc.new {|c| c.assigns["ran_proc_filter1"] = true }, :except => :show_without_filter) { |c| c.assigns["ran_proc_filter2"] = true}
+    before_filter(ConditionalClassFilter, :ensure_login, Proc.new {|c| c.instance_variable_set(:"@ran_proc_filter1", true)}, :except => :show_without_filter) { |c| c.instance_variable_set(:"@ran_proc_filter2", true)}
   end
 
   class ConditionalOptionsFilter < ConditionalFilterController
@@ -225,16 +225,16 @@ class FilterTest < Test::Unit::TestCase
   end
 
   class ProcController < PrependingController
-    before_filter(proc { |c| c.assigns["ran_proc_filter"] = true })
+    before_filter(proc { |c| c.instance_variable_set(:"@ran_proc_filter", true) })
   end
 
   class ImplicitProcController < PrependingController
-    before_filter { |c| c.assigns["ran_proc_filter"] = true }
+    before_filter { |c| c.instance_variable_set(:"@ran_proc_filter", true) }
   end
 
   class AuditFilter
     def self.filter(controller)
-      controller.assigns["was_audited"] = true
+      controller.instance_variable_set(:"@was_audited", true)
     end
   end
 
@@ -242,12 +242,12 @@ class FilterTest < Test::Unit::TestCase
     def before(controller)
       @execution_log = "before"
       controller.class.execution_log << " before aroundfilter " if controller.respond_to? :execution_log
-      controller.assigns["before_ran"] = true
+      controller.instance_variable_set(:"@before_ran", true)
     end
 
     def after(controller)
-      controller.assigns["execution_log"] = @execution_log + " and after"
-      controller.assigns["after_ran"] = true
+      controller.instance_variable_set(:"@execution_log", @execution_log + " and after")
+      controller.instance_variable_set(:"@after_ran", true)
       controller.class.execution_log << " after aroundfilter " if controller.respond_to? :execution_log
     end
   end
@@ -364,7 +364,7 @@ class FilterTest < Test::Unit::TestCase
       begin
         yield
       rescue ErrorToRescue => ex
-        controller.send! :render, :text => "I rescued this: #{ex.inspect}"
+        controller.__send__ :render, :text => "I rescued this: #{ex.inspect}"
       end
     end
   end
@@ -726,9 +726,9 @@ end
 
 class ControllerWithProcFilter < PostsController
   around_filter(:only => :no_raise) do |c,b|
-    c.assigns['before'] = true
+    c.instance_variable_set(:"@before", true)
     b.call
-    c.assigns['after'] = true
+    c.instance_variable_set(:"@after", true)
   end
 end
 

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

@@ -0,0 +1,15 @@
+require 'abstract_unit'
+
+class CDATANodeTest < Test::Unit::TestCase
+  def setup
+    @node = HTML::CDATA.new(nil, 0, 0, "<p>howdy</p>")
+  end
+
+  def test_to_s
+    assert_equal "<![CDATA[<p>howdy</p>]]>", @node.to_s
+  end
+
+  def test_content
+    assert_equal "<p>howdy</p>", @node.content
+  end
+end

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

@@ -65,4 +65,25 @@ class NodeTest < Test::Unit::TestCase
     assert_nothing_raised { node = HTML::Node.parse(nil,0,0,s,false) }
     assert node.attributes.has_key?("onmouseover")
   end
+
+  def test_parse_with_valid_cdata_section
+    s = "<![CDATA[<span>contents</span>]]>"
+    node = nil
+    assert_nothing_raised { node = HTML::Node.parse(nil,0,0,s,false) }
+    assert_kind_of HTML::CDATA, node
+    assert_equal '<span>contents</span>', node.content
+  end
+
+  def test_parse_strict_with_unterminated_cdata_section
+    s = "<![CDATA[neverending..."
+    assert_raise(RuntimeError) { HTML::Node.parse(nil,0,0,s) }
+  end
+
+  def test_parse_relaxed_with_unterminated_cdata_section
+    s = "<![CDATA[neverending..."
+    node = nil
+    assert_nothing_raised { node = HTML::Node.parse(nil,0,0,s,false) }
+    assert_kind_of HTML::CDATA, node
+    assert_equal 'neverending...', node.content
+  end
 end

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

@@ -17,6 +17,8 @@ class SanitizerTest < Test::Unit::TestCase
     %{This is a test.\n\n\nIt no longer contains any HTML.\n}, sanitizer.sanitize(
     %{<title>This is <b>a <a href="" target="_blank">test</a></b>.</title>\n\n<!-- it has a comment -->\n\n<p>It no <b>longer <strong>contains <em>any <strike>HTML</strike></em>.</strong></b></p>\n}))
     assert_equal "This has a  here.", sanitizer.sanitize("This has a <!-- comment --> here.")
+    assert_equal "This has a  here.", sanitizer.sanitize("This has a <![CDATA[<section>]]> here.")
+    assert_equal "This has an unclosed ", sanitizer.sanitize("This has an unclosed <![CDATA[<section>]] here...")
     [nil, '', '   '].each { |blank| assert_equal blank, sanitizer.sanitize(blank) }
   end
 
@@ -243,6 +245,18 @@ class SanitizerTest < Test::Unit::TestCase
     assert_sanitized %(<img src='vbscript:msgbox("XSS")' />), '<img />'
   end
 
+  def test_should_sanitize_cdata_section
+    assert_sanitized "<![CDATA[<span>section</span>]]>", "&lt;![CDATA[&lt;span>section&lt;/span>]]>"
+  end
+
+  def test_should_sanitize_unterminated_cdata_section
+    assert_sanitized "<![CDATA[<span>neverending...", "&lt;![CDATA[&lt;span>neverending...]]>"
+  end
+
+  def test_should_not_mangle_urls_with_ampersand
+     assert_sanitized %{<a href=\"http://www.domain.com?var1=1&amp;var2=2\">my link</a>}
+  end
+
 protected
   def assert_sanitized(input, expected = nil)
     @sanitizer ||= HTML::WhiteListSanitizer.new

data/test/controller/integration_test.rb

@@ -1,5 +1,6 @@
 require 'abstract_unit'
 require 'action_controller/integration'
+require 'action_controller/routing'
 
 uses_mocha 'integration' do
 
@@ -12,12 +13,12 @@ end
 
 class SessionTest < Test::Unit::TestCase
   include IntegrationSessionStubbing
-  
+
   def setup
     @session = ActionController::Integration::Session.new
     stub_integration_session(@session)
   end
-  
+
   def test_https_bang_works_and_sets_truth_by_default
     assert !@session.https?
     @session.https!
@@ -196,7 +197,7 @@ class SessionTest < Test::Unit::TestCase
     @session.expects(:process).with(:head,path,params,headers_after_xhr)
     @session.xml_http_request(:head,path,params,headers)
   end
-  
+
   def test_xml_http_request_override_accept
     path = "/index"; params = "blah"; headers = {:location => 'blah', "Accept" => "application/xml"}
     headers_after_xhr = headers.merge(
@@ -227,7 +228,6 @@ class IntegrationTestTest < Test::Unit::TestCase
     assert_equal ::ActionController::Integration::Session, session2.class
     assert_not_equal session1, session2
   end
-
 end
 
 # Tests that integration tests don't call Controller test methods for processing.
@@ -243,10 +243,171 @@ class IntegrationTestUsesCorrectClass < ActionController::IntegrationTest
     reset!
     stub_integration_session(@integration_session)
     %w( get post head put delete ).each do |verb|
-      assert_nothing_raised("'#{verb}' should use integration test methods") { send!(verb, '/') }
+      assert_nothing_raised("'#{verb}' should use integration test methods") { __send__(verb, '/') }
     end
   end
+end
+
+class IntegrationProcessTest < ActionController::IntegrationTest
+  class IntegrationController < ActionController::Base
+    session :off
+
+    def get
+      respond_to do |format|
+        format.html { render :text => "OK", :status => 200 }
+        format.js { render :text => "JS OK", :status => 200 }
+      end
+    end
+
+    def get_with_params
+      render :text => "foo: #{params[:foo]}", :status => 200
+    end
+
+    def post
+      render :text => "Created", :status => 201
+    end
 
+    def cookie_monster
+      cookies["cookie_1"] = nil
+      cookies["cookie_3"] = "chocolate"
+      render :text => "Gone", :status => 410
+    end
+
+    def redirect
+      redirect_to :action => "get"
+    end
+  end
+
+  def test_get
+    with_test_route_set do
+      get '/get'
+      assert_equal 200, status
+      assert_equal "OK", status_message
+      assert_equal "200 OK", response.headers["Status"]
+      assert_equal ["200 OK"], headers["status"]
+      assert_response 200
+      assert_response :success
+      assert_response :ok
+      assert_equal [], response.headers["cookie"]
+      assert_equal [], headers["cookie"]
+      assert_equal({}, cookies)
+      assert_equal "OK", response.body
+      assert_kind_of HTML::Document, html_document
+      assert_equal 1, request_count
+    end
+  end
+
+  def test_post
+    with_test_route_set do
+      post '/post'
+      assert_equal 201, status
+      assert_equal "Created", status_message
+      assert_equal "201 Created", response.headers["Status"]
+      assert_equal ["201 Created"], headers["status"]
+      assert_response 201
+      assert_response :success
+      assert_response :created
+      assert_equal [], response.headers["cookie"]
+      assert_equal [], headers["cookie"]
+      assert_equal({}, cookies)
+      assert_equal "Created", response.body
+      assert_kind_of HTML::Document, html_document
+      assert_equal 1, request_count
+    end
+  end
+
+  def test_cookie_monster
+    with_test_route_set do
+      self.cookies['cookie_1'] = "sugar"
+      self.cookies['cookie_2'] = "oatmeal"
+      get '/cookie_monster'
+      assert_equal 410, status
+      assert_equal "Gone", status_message
+      assert_equal "410 Gone", response.headers["Status"]
+      assert_equal ["410 Gone"], headers["status"]
+      assert_response 410
+      assert_response :gone
+      assert_equal ["cookie_1=; path=/", "cookie_3=chocolate; path=/"], response.headers["Set-Cookie"]
+      assert_equal ["cookie_1=; path=/", "cookie_3=chocolate; path=/"], headers['set-cookie']
+      assert_equal [
+        CGI::Cookie::new("name" => "cookie_1", "value" => ""),
+        CGI::Cookie::new("name" => "cookie_3", "value" => "chocolate")
+      ], response.headers["cookie"]
+      assert_equal [], headers["cookie"]
+      assert_equal({"cookie_1"=>"", "cookie_2"=>"oatmeal", "cookie_3"=>"chocolate"}, cookies)
+      assert_equal "Gone", response.body
+    end
+  end
+
+  def test_redirect
+    with_test_route_set do
+      get '/redirect'
+      assert_equal 302, status
+      assert_equal "Found", status_message
+      assert_equal "302 Found", response.headers["Status"]
+      assert_equal ["302 Found"], headers["status"]
+      assert_response 302
+      assert_response :redirect
+      assert_response :found
+      assert_equal "<html><body>You are being <a href=\"http://www.example.com/get\">redirected</a>.</body></html>", response.body
+      assert_kind_of HTML::Document, html_document
+      assert_equal 1, request_count
+    end
+  end
+
+  def test_xml_http_request_get
+    with_test_route_set do
+      xhr :get, '/get'
+      assert_equal 200, status
+      assert_equal "OK", status_message
+      assert_equal "200 OK", response.headers["Status"]
+      assert_equal ["200 OK"], headers["status"]
+      assert_response 200
+      assert_response :success
+      assert_response :ok
+      assert_equal "JS OK", response.body
+    end
+  end
+
+  def test_get_with_query_string
+    with_test_route_set do
+      get '/get_with_params?foo=bar'
+      assert_equal '/get_with_params?foo=bar', request.env["REQUEST_URI"]
+      assert_equal '/get_with_params?foo=bar', request.request_uri
+      assert_equal nil, request.env["QUERY_STRING"]
+      assert_equal 'foo=bar', request.query_string
+      assert_equal 'bar', request.parameters['foo']
+
+      assert_equal 200, status
+      assert_equal "foo: bar", response.body
+    end
+  end
+
+  def test_get_with_parameters
+    with_test_route_set do
+      get '/get_with_params', :foo => "bar"
+      assert_equal '/get_with_params', request.env["REQUEST_URI"]
+      assert_equal '/get_with_params', request.request_uri
+      assert_equal 'foo=bar', request.env["QUERY_STRING"]
+      assert_equal 'foo=bar', request.query_string
+      assert_equal 'bar', request.parameters['foo']
+
+      assert_equal 200, status
+      assert_equal "foo: bar", response.body
+    end
+  end
+
+  private
+    def with_test_route_set
+      with_routing do |set|
+        set.draw do |map|
+          map.with_options :controller => "IntegrationProcessTest::Integration" do |c|
+            c.connect "/:action"
+          end
+        end
+        yield
+      end
+    end
 end
 
-end # uses_mocha
+end

data/test/controller/layout_test.rb

@@ -31,16 +31,8 @@ end
 class MultipleExtensions < LayoutTest
 end
 
-class MabView < ActionView::TemplateHandler
-  def initialize(view)
-  end
-  
-  def render(template)
-    template.source
-  end
-end
-
-ActionView::Template::register_template_handler :mab, MabView
+ActionView::Template::register_template_handler :mab,
+  lambda { |template| template.source.inspect }
 
 class LayoutAutoDiscoveryTest < Test::Unit::TestCase
   def setup
@@ -49,20 +41,21 @@ class LayoutAutoDiscoveryTest < Test::Unit::TestCase
 
     @request.host = "www.nextangle.com"
   end
-  
+
   def test_application_layout_is_default_when_no_controller_match
     @controller = ProductController.new
     get :hello
     assert_equal 'layout_test.rhtml hello.rhtml', @response.body
   end
-  
+
   def test_controller_name_layout_name_match
     @controller = ItemController.new
     get :hello
     assert_equal 'item.rhtml hello.rhtml', @response.body
   end
-  
+
   def test_third_party_template_library_auto_discovers_layout
+    ThirdPartyTemplateLibraryController.view_paths.reload!
     @controller = ThirdPartyTemplateLibraryController.new
     get :hello
     assert_equal 'layouts/third_party_template_library', @controller.active_layout
@@ -70,14 +63,14 @@ class LayoutAutoDiscoveryTest < Test::Unit::TestCase
     assert_response :success
     assert_equal 'Mab', @response.body
   end
-  
+
   def test_namespaced_controllers_auto_detect_layouts
     @controller = ControllerNameSpace::NestedController.new
     get :hello
     assert_equal 'layouts/controller_name_space/nested', @controller.active_layout
     assert_equal 'controller_name_space/nested.rhtml hello.rhtml', @response.body
   end
-  
+
   def test_namespaced_controllers_auto_detect_layouts
     @controller = MultipleExtensions.new
     get :hello
@@ -86,53 +79,6 @@ class LayoutAutoDiscoveryTest < Test::Unit::TestCase
   end
 end
 
-class ExemptFromLayoutTest < Test::Unit::TestCase
-  def setup
-    @controller = LayoutTest.new
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-  end
-
-  def test_rjs_exempt_from_layout
-    assert @controller.send!(:template_exempt_from_layout?, 'test.rjs')
-  end
-
-  def test_rhtml_and_rxml_not_exempt_from_layout
-    assert !@controller.send!(:template_exempt_from_layout?, 'test.rhtml')
-    assert !@controller.send!(:template_exempt_from_layout?, 'test.rxml')
-  end
-
-  def test_other_extension_not_exempt_from_layout
-    assert !@controller.send!(:template_exempt_from_layout?, 'test.random')
-  end
-
-  def test_add_extension_to_exempt_from_layout
-    ['rpdf', :rpdf].each do |ext|
-      assert_nothing_raised do
-        ActionController::Base.exempt_from_layout ext
-      end
-      assert @controller.send!(:template_exempt_from_layout?, "test.#{ext}")
-    end
-  end
-
-  def test_add_regexp_to_exempt_from_layout
-    ActionController::Base.exempt_from_layout /\.rdoc/
-    assert @controller.send!(:template_exempt_from_layout?, 'test.rdoc')
-  end
-
-  def test_rhtml_exempt_from_layout_status_should_prevent_layout_render
-    ActionController::Base.exempt_from_layout :rhtml
-    
-    assert @controller.send!(:template_exempt_from_layout?, 'test.rhtml')
-    assert @controller.send!(:template_exempt_from_layout?, 'hello.rhtml')
-
-    get :hello
-    assert_equal 'hello.rhtml', @response.body
-    ActionController::Base.exempt_from_layout.delete(/\.rhtml$/)
-  end
-end
-
-
 class DefaultLayoutController < LayoutTest
 end
 
@@ -163,19 +109,19 @@ class LayoutSetInResponseTest < Test::Unit::TestCase
     get :hello
     assert_equal 'layouts/layout_test', @response.layout
   end
-  
+
   def test_layout_set_when_set_in_controller
     @controller = HasOwnLayoutController.new
     get :hello
     assert_equal 'layouts/item', @response.layout
   end
-  
+
   def test_layout_set_when_using_render
     @controller = SetsLayoutInRenderController.new
     get :hello
     assert_equal 'layouts/third_party_template_library', @response.layout
   end
-  
+
   def test_layout_is_not_set_when_none_rendered
     @controller = RendersNoLayoutController.new
     get :hello
@@ -186,8 +132,6 @@ class LayoutSetInResponseTest < Test::Unit::TestCase
     ActionController::Base.exempt_from_layout :rhtml
     @controller = RenderWithTemplateOptionController.new
 
-    assert @controller.send(:template_exempt_from_layout?, 'alt/hello.rhtml')
-
     get :hello
     assert_equal "alt/hello.rhtml", @response.body.strip
 
@@ -256,4 +200,3 @@ class LayoutSymlinkedIsRenderedTest < Test::Unit::TestCase
     assert_equal "layouts/symlinked/symlinked_layout", @response.layout
   end
 end
-