actionpack 2.2.3 → 2.3.2

data/test/activerecord/render_partial_with_record_identification_test.rb

@@ -47,19 +47,13 @@ class RenderPartialWithRecordIdentificationController < ActionController::Base
 end
 
 class RenderPartialWithRecordIdentificationTest < ActiveRecordTestCase
+  tests RenderPartialWithRecordIdentificationController
   fixtures :developers, :projects, :developers_projects, :topics, :replies, :companies, :mascots
 
-  def setup
-    @controller = RenderPartialWithRecordIdentificationController.new
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-    super
-  end
-
   def test_rendering_partial_with_has_many_and_belongs_to_association
     get :render_with_has_many_and_belongs_to_association
     assert_template 'projects/_project'
-    assert_equal 'Active RecordActive Controller', @response.body
+    assert_equal assigns(:developer).projects.map(&:name).join, @response.body
   end
 
   def test_rendering_partial_with_has_many_association
@@ -88,7 +82,7 @@ class RenderPartialWithRecordIdentificationTest < ActiveRecordTestCase
 
   def test_render_with_record_collection_and_spacer_template
     get :render_with_record_collection_and_spacer_template
-    assert_equal 'Active Recordonly partialActive Controller', @response.body
+    assert_equal assigns(:developer).projects.map(&:name).join('only partial'), @response.body
   end
 
   def test_rendering_partial_with_has_one_association
@@ -162,12 +156,7 @@ module Fun
 end
 
 class RenderPartialWithRecordIdentificationAndNestedControllersTest < ActiveRecordTestCase
-  def setup
-    @controller = Fun::NestedController.new
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-    super
-  end
+  tests Fun::NestedController
 
   def test_render_with_record_in_nested_controller
     get :render_with_record_in_nested_controller
@@ -183,12 +172,7 @@ class RenderPartialWithRecordIdentificationAndNestedControllersTest < ActiveReco
 end
 
 class RenderPartialWithRecordIdentificationAndNestedDeeperControllersTest < ActiveRecordTestCase
-  def setup
-    @controller = Fun::Serious::NestedDeeperController.new
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-    super
-  end
+  tests Fun::Serious::NestedDeeperController
 
   def test_render_with_record_in_deeper_nested_controller
     get :render_with_record_in_deeper_nested_controller

data/test/controller/action_pack_assertions_test.rb

@@ -165,13 +165,11 @@ module Admin
 end
 
 # a test case to exercise the new capabilities TestRequest & TestResponse
-class ActionPackAssertionsControllerTest < Test::Unit::TestCase
+class ActionPackAssertionsControllerTest < ActionController::TestCase
   # let's get this party started
   def setup
     ActionController::Routing::Routes.reload
     ActionController::Routing.use_controllers!(%w(action_pack_assertions admin/inner_module user content admin/user))
-    @controller = ActionPackAssertionsController.new
-    @request, @response = ActionController::TestRequest.new, ActionController::TestResponse.new
   end
 
   def teardown
@@ -235,13 +233,13 @@ class ActionPackAssertionsControllerTest < Test::Unit::TestCase
         map.connect   ':controller/:action/:id'
       end
       process :redirect_to_named_route
-      assert_raise(Test::Unit::AssertionFailedError) do
+      assert_raise(ActiveSupport::TestCase::Assertion) do
         assert_redirected_to 'http://test.host/route_two'
       end
-      assert_raise(Test::Unit::AssertionFailedError) do
+      assert_raise(ActiveSupport::TestCase::Assertion) do
         assert_redirected_to :controller => 'action_pack_assertions', :action => 'nothing', :id => 'two'
       end
-      assert_raise(Test::Unit::AssertionFailedError) do
+      assert_raise(ActiveSupport::TestCase::Assertion) do
         assert_redirected_to route_two_url
       end
     end
@@ -328,11 +326,11 @@ class ActionPackAssertionsControllerTest < Test::Unit::TestCase
   # check if we were rendered by a file-based template?
   def test_rendered_action
     process :nothing
-    assert_nil @response.rendered_template
+    assert_nil @response.rendered[:template]
 
     process :hello_world
-    assert @response.rendered_template
-    assert 'hello_world', @response.rendered_template.to_s
+    assert @response.rendered[:template]
+    assert 'hello_world', @response.rendered[:template].to_s
   end
 
   # check the redirection location
@@ -368,6 +366,12 @@ class ActionPackAssertionsControllerTest < Test::Unit::TestCase
     assert @response.missing?
   end
 
+  # check client errors
+  def test_client_error_response_code
+    process :response404
+    assert @response.client_error?
+  end
+
   # check to see if our redirection matches a pattern
   def test_redirect_url_match
     process :redirect_external
@@ -410,7 +414,7 @@ class ActionPackAssertionsControllerTest < Test::Unit::TestCase
 
   def test_assert_redirection_fails_with_incorrect_controller
     process :redirect_to_controller
-    assert_raise(Test::Unit::AssertionFailedError) do
+    assert_raise(ActiveSupport::TestCase::Assertion) do
       assert_redirected_to :controller => "action_pack_assertions", :action => "flash_me"
     end
   end
@@ -457,16 +461,16 @@ class ActionPackAssertionsControllerTest < Test::Unit::TestCase
 
   def test_assert_valid
     get :get_valid_record
-    assert_valid assigns('record')
+    assert_deprecated { assert_valid assigns('record') }
   end
 
   def test_assert_valid_failing
     get :get_invalid_record
 
     begin
-      assert_valid assigns('record')
+      assert_deprecated { assert_valid assigns('record') }
       assert false
-    rescue Test::Unit::AssertionFailedError => e
+    rescue ActiveSupport::TestCase::Assertion => e
     end
   end
 
@@ -475,7 +479,7 @@ class ActionPackAssertionsControllerTest < Test::Unit::TestCase
     get :index
     assert_response :success
     flunk 'Expected non-success response'
-  rescue Test::Unit::AssertionFailedError => e
+  rescue ActiveSupport::TestCase::Assertion => e
     assert e.message.include?('FAIL')
   end
 
@@ -484,31 +488,29 @@ class ActionPackAssertionsControllerTest < Test::Unit::TestCase
     get :show
     assert_response :success
     flunk 'Expected non-success response'
-  rescue Test::Unit::AssertionFailedError
+  rescue ActiveSupport::TestCase::Assertion
+    # success
   rescue
     flunk "assert_response failed to handle failure response with missing, but optional, exception."
   end
 end
 
-class ActionPackHeaderTest < Test::Unit::TestCase
-  def setup
-    @controller = ActionPackAssertionsController.new
-    @request, @response = ActionController::TestRequest.new, ActionController::TestResponse.new
-  end
+class ActionPackHeaderTest < ActionController::TestCase
+  tests ActionPackAssertionsController
 
   def test_rendering_xml_sets_content_type
     process :hello_xml_world
-    assert_equal('application/xml; charset=utf-8', @response.headers['type'])
+    assert_equal('application/xml; charset=utf-8', @response.headers['Content-Type'])
   end
 
   def test_rendering_xml_respects_content_type
     @response.headers['type'] = 'application/pdf'
     process :hello_xml_world
-    assert_equal('application/pdf; charset=utf-8', @response.headers['type'])
+    assert_equal('application/pdf; charset=utf-8', @response.headers['Content-Type'])
   end
 
   def test_render_text_with_custom_content_type
     get :render_text_with_custom_content_type
-    assert_equal 'application/rss+xml; charset=utf-8', @response.headers['type']
+    assert_equal 'application/rss+xml; charset=utf-8', @response.headers['Content-Type']
   end
 end

data/test/controller/addresses_render_test.rb

@@ -19,17 +19,14 @@ class AddressesTestController < ActionController::Base
   def self.controller_path; "addresses"; end
 end
 
-class AddressesTest < Test::Unit::TestCase
-  def setup
-    @controller = AddressesTestController.new
+class AddressesTest < ActionController::TestCase
+  tests AddressesTestController
 
+  def setup
     # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
     # a more accurate simulation of what happens in "real life".
     @controller.logger = Logger.new(nil)
 
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-
     @request.host = "www.nextangle.com"
   end
 

data/test/controller/assert_select_test.rb

@@ -9,9 +9,10 @@ require 'controller/fake_controllers'
 
 unless defined?(ActionMailer)
   begin
-    $:.unshift(File.dirname(__FILE__) + "/../../../actionmailer/lib")
+    $:.unshift("#{File.dirname(__FILE__)}/../../../actionmailer/lib")
     require 'action_mailer'
-  rescue LoadError
+  rescue LoadError => e
+    raise unless e.message =~ /action_mailer/
     require 'rubygems'
     gem 'actionmailer'
   end
@@ -19,7 +20,18 @@ end
 
 ActionMailer::Base.template_root = FIXTURE_LOAD_PATH
 
-class AssertSelectTest < Test::Unit::TestCase
+class AssertSelectTest < ActionController::TestCase
+  Assertion = ActiveSupport::TestCase::Assertion
+
+  class AssertSelectMailer < ActionMailer::Base
+    def test(html)
+      recipients "test <test@test.host>"
+      from "test@test.host"
+      subject "Test e-mail"
+      part :content_type=>"text/html", :body=>html
+    end
+  end
+
   class AssertSelectController < ActionController::Base
     def response_with=(content)
       @content = content
@@ -51,21 +63,9 @@ class AssertSelectTest < Test::Unit::TestCase
     end
   end
 
-  class AssertSelectMailer < ActionMailer::Base
-    def test(html)
-      recipients "test <test@test.host>"
-      from "test@test.host"
-      subject "Test e-mail"
-      part :content_type=>"text/html", :body=>html
-    end
-  end
-
-  AssertionFailedError = Test::Unit::AssertionFailedError
+  tests AssertSelectController
 
   def setup
-    @controller = AssertSelectController.new
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
     ActionMailer::Base.delivery_method = :test
     ActionMailer::Base.perform_deliveries = true
     ActionMailer::Base.deliveries = []
@@ -76,7 +76,7 @@ class AssertSelectTest < Test::Unit::TestCase
   end
 
   def assert_failure(message, &block)
-    e = assert_raises(AssertionFailedError, &block)
+    e = assert_raise(Assertion, &block)
     assert_match(message, e.message) if Regexp === message
     assert_equal(message, e.message) if String === message
   end
@@ -94,43 +94,43 @@ class AssertSelectTest < Test::Unit::TestCase
 
   def test_equality_true_false
     render_html %Q{<div id="1"></div><div id="2"></div>}
-    assert_nothing_raised               { assert_select "div" }
-    assert_raises(AssertionFailedError) { assert_select "p" }
-    assert_nothing_raised               { assert_select "div", true }
-    assert_raises(AssertionFailedError) { assert_select "p", true }
-    assert_raises(AssertionFailedError) { assert_select "div", false }
-    assert_nothing_raised               { assert_select "p", false }
+    assert_nothing_raised    { assert_select "div" }
+    assert_raise(Assertion) { assert_select "p" }
+    assert_nothing_raised    { assert_select "div", true }
+    assert_raise(Assertion) { assert_select "p", true }
+    assert_raise(Assertion) { assert_select "div", false }
+    assert_nothing_raised    { assert_select "p", false }
   end
 
   def test_equality_string_and_regexp
     render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
-    assert_nothing_raised               { assert_select "div", "foo" }
-    assert_raises(AssertionFailedError) { assert_select "div", "bar" }
-    assert_nothing_raised               { assert_select "div", :text=>"foo" }
-    assert_raises(AssertionFailedError) { assert_select "div", :text=>"bar" }
-    assert_nothing_raised               { assert_select "div", /(foo|bar)/ }
-    assert_raises(AssertionFailedError) { assert_select "div", /foobar/ }
-    assert_nothing_raised               { assert_select "div", :text=>/(foo|bar)/ }
-    assert_raises(AssertionFailedError) { assert_select "div", :text=>/foobar/ }
-    assert_raises(AssertionFailedError) { assert_select "p", :text=>/foobar/ }
+    assert_nothing_raised    { assert_select "div", "foo" }
+    assert_raise(Assertion) { assert_select "div", "bar" }
+    assert_nothing_raised    { assert_select "div", :text=>"foo" }
+    assert_raise(Assertion) { assert_select "div", :text=>"bar" }
+    assert_nothing_raised    { assert_select "div", /(foo|bar)/ }
+    assert_raise(Assertion) { assert_select "div", /foobar/ }
+    assert_nothing_raised    { assert_select "div", :text=>/(foo|bar)/ }
+    assert_raise(Assertion) { assert_select "div", :text=>/foobar/ }
+    assert_raise(Assertion) { assert_select "p", :text=>/foobar/ }
   end
 
   def test_equality_of_html
     render_html %Q{<p>\n<em>"This is <strong>not</strong> a big problem,"</em> he said.\n</p>}
     text = "\"This is not a big problem,\" he said."
     html = "<em>\"This is <strong>not</strong> a big problem,\"</em> he said."
-    assert_nothing_raised               { assert_select "p", text }
-    assert_raises(AssertionFailedError) { assert_select "p", html }
-    assert_nothing_raised               { assert_select "p", :html=>html }
-    assert_raises(AssertionFailedError) { assert_select "p", :html=>text }
+    assert_nothing_raised    { assert_select "p", text }
+    assert_raise(Assertion) { assert_select "p", html }
+    assert_nothing_raised    { assert_select "p", :html=>html }
+    assert_raise(Assertion) { assert_select "p", :html=>text }
     # No stripping for pre.
     render_html %Q{<pre>\n<em>"This is <strong>not</strong> a big problem,"</em> he said.\n</pre>}
     text = "\n\"This is not a big problem,\" he said.\n"
     html = "\n<em>\"This is <strong>not</strong> a big problem,\"</em> he said.\n"
-    assert_nothing_raised               { assert_select "pre", text }
-    assert_raises(AssertionFailedError) { assert_select "pre", html }
-    assert_nothing_raised               { assert_select "pre", :html=>html }
-    assert_raises(AssertionFailedError) { assert_select "pre", :html=>text }
+    assert_nothing_raised    { assert_select "pre", text }
+    assert_raise(Assertion) { assert_select "pre", html }
+    assert_nothing_raised    { assert_select "pre", :html=>html }
+    assert_raise(Assertion) { assert_select "pre", :html=>text }
   end
 
   def test_counts
@@ -206,16 +206,16 @@ class AssertSelectTest < Test::Unit::TestCase
   def test_assert_select_text_match
     render_html %Q{<div id="1"><span>foo</span></div><div id="2"><span>bar</span></div>}
     assert_select "div" do
-      assert_nothing_raised               { assert_select "div", "foo" }
-      assert_nothing_raised               { assert_select "div", "bar" }
-      assert_nothing_raised               { assert_select "div", /\w*/ }
-      assert_nothing_raised               { assert_select "div", /\w*/, :count=>2 }
-      assert_raises(AssertionFailedError) { assert_select "div", :text=>"foo", :count=>2 }
-      assert_nothing_raised               { assert_select "div", :html=>"<span>bar</span>" }
-      assert_nothing_raised               { assert_select "div", :html=>"<span>bar</span>" }
-      assert_nothing_raised               { assert_select "div", :html=>/\w*/ }
-      assert_nothing_raised               { assert_select "div", :html=>/\w*/, :count=>2 }
-      assert_raises(AssertionFailedError) { assert_select "div", :html=>"<span>foo</span>", :count=>2 }
+      assert_nothing_raised    { assert_select "div", "foo" }
+      assert_nothing_raised    { assert_select "div", "bar" }
+      assert_nothing_raised    { assert_select "div", /\w*/ }
+      assert_nothing_raised    { assert_select "div", /\w*/, :count=>2 }
+      assert_raise(Assertion) { assert_select "div", :text=>"foo", :count=>2 }
+      assert_nothing_raised    { assert_select "div", :html=>"<span>bar</span>" }
+      assert_nothing_raised    { assert_select "div", :html=>"<span>bar</span>" }
+      assert_nothing_raised    { assert_select "div", :html=>/\w*/ }
+      assert_nothing_raised    { assert_select "div", :html=>/\w*/, :count=>2 }
+      assert_raise(Assertion) { assert_select "div", :html=>"<span>foo</span>", :count=>2 }
     end
   end
 
@@ -248,6 +248,19 @@ class AssertSelectTest < Test::Unit::TestCase
     end
   end
 
+  def test_assert_select_rjs_for_positioned_insert_should_fail_when_mixing_arguments
+    render_rjs do |page|
+      page.insert_html :top, "test1", "<div id=\"1\">foo</div>"
+      page.insert_html :bottom, "test2", "<div id=\"2\">foo</div>"
+    end
+    assert_raise(Assertion) {assert_select_rjs :insert, :top, "test2"}
+  end
+
+  def test_elect_with_xml_namespace_attributes
+    render_html %Q{<link xlink:href="http://nowhere.com"></link>}
+    assert_nothing_raised { assert_select "link[xlink:href=http://nowhere.com]" }
+  end
+
   #
   # Test css_select.
   #
@@ -323,7 +336,7 @@ class AssertSelectTest < Test::Unit::TestCase
   # Test that we fail if there is nothing to pick.
   def test_assert_select_rjs_fails_if_nothing_to_pick
     render_rjs { }
-    assert_raises(AssertionFailedError) { assert_select_rjs }
+    assert_raise(Assertion) { assert_select_rjs }
   end
 
   def test_assert_select_rjs_with_unicode
@@ -338,10 +351,10 @@ class AssertSelectTest < Test::Unit::TestCase
       if str.respond_to?(:force_encoding)
         str.force_encoding(Encoding::UTF_8)
         assert_select str, /\343\203\201..\343\203\210/u
-        assert_raises(AssertionFailedError) { assert_select str, /\343\203\201.\343\203\210/u }
+        assert_raise(Assertion) { assert_select str, /\343\203\201.\343\203\210/u }
       else
         assert_select str, Regexp.new("\343\203\201..\343\203\210",0,'U')
-        assert_raises(AssertionFailedError) { assert_select str, Regexp.new("\343\203\201.\343\203\210",0,'U') }
+        assert_raise(Assertion) { assert_select str, Regexp.new("\343\203\201.\343\203\210",0,'U') }
       end
     end
   end
@@ -365,7 +378,7 @@ class AssertSelectTest < Test::Unit::TestCase
       assert_select "div", 1
       assert_select "#3"
     end
-    assert_raises(AssertionFailedError) { assert_select_rjs "test4" }
+    assert_raise(Assertion) { assert_select_rjs "test4" }
   end
 
   def test_assert_select_rjs_for_replace
@@ -383,7 +396,7 @@ class AssertSelectTest < Test::Unit::TestCase
       assert_select "div", 1
       assert_select "#1"
     end
-    assert_raises(AssertionFailedError) { assert_select_rjs :replace, "test2" }
+    assert_raise(Assertion) { assert_select_rjs :replace, "test2" }
     # Replace HTML.
     assert_select_rjs :replace_html do
       assert_select "div", 1
@@ -393,7 +406,7 @@ class AssertSelectTest < Test::Unit::TestCase
       assert_select "div", 1
       assert_select "#2"
     end
-    assert_raises(AssertionFailedError) { assert_select_rjs :replace_html, "test1" }
+    assert_raise(Assertion) { assert_select_rjs :replace_html, "test1" }
   end
 
   def test_assert_select_rjs_for_chained_replace
@@ -411,7 +424,7 @@ class AssertSelectTest < Test::Unit::TestCase
       assert_select "div", 1
       assert_select "#1"
     end
-    assert_raises(AssertionFailedError) { assert_select_rjs :chained_replace, "test2" }
+    assert_raise(Assertion) { assert_select_rjs :chained_replace, "test2" }
     # Replace HTML.
     assert_select_rjs :chained_replace_html do
       assert_select "div", 1
@@ -421,7 +434,7 @@ class AssertSelectTest < Test::Unit::TestCase
       assert_select "div", 1
       assert_select "#2"
     end
-    assert_raises(AssertionFailedError) { assert_select_rjs :replace_html, "test1" }
+    assert_raise(Assertion) { assert_select_rjs :replace_html, "test1" }
   end
 
   # Simple remove
@@ -440,8 +453,8 @@ class AssertSelectTest < Test::Unit::TestCase
 
     assert_select_rjs :remove, "test1"
 
-    rescue Test::Unit::AssertionFailedError
-      assert_equal "No RJS statement that removes 'test1' was rendered.", $!.message
+  rescue Assertion
+    assert_equal "No RJS statement that removes 'test1' was rendered.", $!.message
   end
 
   def test_assert_select_rjs_for_remove_ignores_block
@@ -472,8 +485,8 @@ class AssertSelectTest < Test::Unit::TestCase
 
     assert_select_rjs :show, "test1"
 
-    rescue Test::Unit::AssertionFailedError
-      assert_equal "No RJS statement that shows 'test1' was rendered.", $!.message
+  rescue Assertion
+    assert_equal "No RJS statement that shows 'test1' was rendered.", $!.message
   end
 
   def test_assert_select_rjs_for_show_ignores_block
@@ -504,8 +517,8 @@ class AssertSelectTest < Test::Unit::TestCase
 
     assert_select_rjs :hide, "test1"
 
-    rescue Test::Unit::AssertionFailedError
-      assert_equal "No RJS statement that hides 'test1' was rendered.", $!.message
+  rescue Assertion
+    assert_equal "No RJS statement that hides 'test1' was rendered.", $!.message
   end
 
   def test_assert_select_rjs_for_hide_ignores_block
@@ -536,8 +549,8 @@ class AssertSelectTest < Test::Unit::TestCase
 
     assert_select_rjs :toggle, "test1"
 
-    rescue Test::Unit::AssertionFailedError
-      assert_equal "No RJS statement that toggles 'test1' was rendered.", $!.message
+  rescue Assertion
+    assert_equal "No RJS statement that toggles 'test1' was rendered.", $!.message
   end
 
   def test_assert_select_rjs_for_toggle_ignores_block
@@ -567,7 +580,7 @@ class AssertSelectTest < Test::Unit::TestCase
       assert_select "div", 1
       assert_select "#3"
     end
-    assert_raises(AssertionFailedError) { assert_select_rjs :insert_html, "test1" }
+    assert_raise(Assertion) { assert_select_rjs :insert_html, "test1" }
   end
 
   # Positioned insert.
@@ -600,8 +613,8 @@ class AssertSelectTest < Test::Unit::TestCase
   end
 
   def test_assert_select_rjs_raise_errors
-    assert_raises(ArgumentError) { assert_select_rjs(:destroy) }
-    assert_raises(ArgumentError) { assert_select_rjs(:insert, :left) }
+    assert_raise(ArgumentError) { assert_select_rjs(:destroy) }
+    assert_raise(ArgumentError) { assert_select_rjs(:insert, :left) }
   end
 
   # Simple selection from a single result.
@@ -693,7 +706,7 @@ EOF
   #
 
   def test_assert_select_email
-    assert_raises(AssertionFailedError) { assert_select_email {} }
+    assert_raise(Assertion) { assert_select_email {} }
     AssertSelectMailer.deliver_test "<div><p>foo</p><p>bar</p></div>"
     assert_select_email do
       assert_select "div:root" do