Ruby 1.9 compat: rename deprecated assert_raises to assert_raise.

[#1617 state:resolved]

12 files changed, 89 insertions, 89 deletions

diff --git a/actionpack/test/controller/assert_select_test.rb b/actionpack/test/controller/assert_select_test.rb
index c543118530..298c7e4db3 100644
--- a/actionpack/test/controller/assert_select_test.rb
+++ b/actionpack/test/controller/assert_select_test.rb
@@ -76,7 +76,7 @@ class AssertSelectTest < ActionController::TestCase
   end
 
   def assert_failure(message, &block)
-    e = assert_raises(Assertion, &block)
+    e = assert_raise(Assertion, &block)
     assert_match(message, e.message) if Regexp === message
     assert_equal(message, e.message) if String === message
   end
@@ -95,24 +95,24 @@ class AssertSelectTest < ActionController::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(Assertion) { assert_select "p" }
+    assert_raise(Assertion) { assert_select "p" }
     assert_nothing_raised    { assert_select "div", true }
-    assert_raises(Assertion) { assert_select "p", true }
-    assert_raises(Assertion) { assert_select "div", false }
+    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(Assertion) { assert_select "div", "bar" }
+    assert_raise(Assertion) { assert_select "div", "bar" }
     assert_nothing_raised    { assert_select "div", :text=>"foo" }
-    assert_raises(Assertion) { assert_select "div", :text=>"bar" }
+    assert_raise(Assertion) { assert_select "div", :text=>"bar" }
     assert_nothing_raised    { assert_select "div", /(foo|bar)/ }
-    assert_raises(Assertion) { assert_select "div", /foobar/ }
+    assert_raise(Assertion) { assert_select "div", /foobar/ }
     assert_nothing_raised    { assert_select "div", :text=>/(foo|bar)/ }
-    assert_raises(Assertion) { assert_select "div", :text=>/foobar/ }
-    assert_raises(Assertion) { assert_select "p", :text=>/foobar/ }
+    assert_raise(Assertion) { assert_select "div", :text=>/foobar/ }
+    assert_raise(Assertion) { assert_select "p", :text=>/foobar/ }
   end
 
   def test_equality_of_html
@@ -120,17 +120,17 @@ class AssertSelectTest < ActionController::TestCase
     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(Assertion) { assert_select "p", html }
+    assert_raise(Assertion) { assert_select "p", html }
     assert_nothing_raised    { assert_select "p", :html=>html }
-    assert_raises(Assertion) { assert_select "p", :html=>text }
+    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(Assertion) { assert_select "pre", html }
+    assert_raise(Assertion) { assert_select "pre", html }
     assert_nothing_raised    { assert_select "pre", :html=>html }
-    assert_raises(Assertion) { assert_select "pre", :html=>text }
+    assert_raise(Assertion) { assert_select "pre", :html=>text }
   end
 
   def test_counts
@@ -210,12 +210,12 @@ class AssertSelectTest < ActionController::TestCase
       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(Assertion) { assert_select "div", :text=>"foo", :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_raises(Assertion) { assert_select "div", :html=>"<span>foo</span>", :count=>2 }
+      assert_raise(Assertion) { assert_select "div", :html=>"<span>foo</span>", :count=>2 }
     end
   end
 
@@ -253,7 +253,7 @@ class AssertSelectTest < ActionController::TestCase
       page.insert_html :top, "test1", "<div id=\"1\">foo</div>"
       page.insert_html :bottom, "test2", "<div id=\"2\">foo</div>"
     end
-    assert_raises(Assertion) {assert_select_rjs :insert, :top, "test2"}
+    assert_raise(Assertion) {assert_select_rjs :insert, :top, "test2"}
   end
 
   def test_elect_with_xml_namespace_attributes
@@ -336,7 +336,7 @@ class AssertSelectTest < ActionController::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(Assertion) { assert_select_rjs }
+    assert_raise(Assertion) { assert_select_rjs }
   end
 
   def test_assert_select_rjs_with_unicode
@@ -351,10 +351,10 @@ class AssertSelectTest < ActionController::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(Assertion) { 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(Assertion) { 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
@@ -378,7 +378,7 @@ class AssertSelectTest < ActionController::TestCase
       assert_select "div", 1
       assert_select "#3"
     end
-    assert_raises(Assertion) { assert_select_rjs "test4" }
+    assert_raise(Assertion) { assert_select_rjs "test4" }
   end
 
   def test_assert_select_rjs_for_replace
@@ -396,7 +396,7 @@ class AssertSelectTest < ActionController::TestCase
       assert_select "div", 1
       assert_select "#1"
     end
-    assert_raises(Assertion) { 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
@@ -406,7 +406,7 @@ class AssertSelectTest < ActionController::TestCase
       assert_select "div", 1
       assert_select "#2"
     end
-    assert_raises(Assertion) { assert_select_rjs :replace_html, "test1" }
+    assert_raise(Assertion) { assert_select_rjs :replace_html, "test1" }
   end
 
   def test_assert_select_rjs_for_chained_replace
@@ -424,7 +424,7 @@ class AssertSelectTest < ActionController::TestCase
       assert_select "div", 1
       assert_select "#1"
     end
-    assert_raises(Assertion) { 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
@@ -434,7 +434,7 @@ class AssertSelectTest < ActionController::TestCase
       assert_select "div", 1
       assert_select "#2"
     end
-    assert_raises(Assertion) { assert_select_rjs :replace_html, "test1" }
+    assert_raise(Assertion) { assert_select_rjs :replace_html, "test1" }
   end
 
   # Simple remove
@@ -580,7 +580,7 @@ class AssertSelectTest < ActionController::TestCase
       assert_select "div", 1
       assert_select "#3"
     end
-    assert_raises(Assertion) { assert_select_rjs :insert_html, "test1" }
+    assert_raise(Assertion) { assert_select_rjs :insert_html, "test1" }
   end
 
   # Positioned insert.
@@ -613,8 +613,8 @@ class AssertSelectTest < ActionController::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.
@@ -706,7 +706,7 @@ EOF
   #
 
   def test_assert_select_email
-    assert_raises(Assertion) { 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
diff --git a/actionpack/test/controller/html-scanner/document_test.rb b/actionpack/test/controller/html-scanner/document_test.rb
index 1c3facb9e3..c68f04fa75 100644
--- a/actionpack/test/controller/html-scanner/document_test.rb
+++ b/actionpack/test/controller/html-scanner/document_test.rb
@@ -134,7 +134,7 @@ HTML
   end
 
   def test_invalid_document_raises_exception_when_strict
-    assert_raises RuntimeError do
+    assert_raise RuntimeError do
       doc = HTML::Document.new("<html>
         <table>
           <tr>
diff --git a/actionpack/test/controller/mime_responds_test.rb b/actionpack/test/controller/mime_responds_test.rb
index dc59180a68..edd7162325 100644
--- a/actionpack/test/controller/mime_responds_test.rb
+++ b/actionpack/test/controller/mime_responds_test.rb
@@ -469,7 +469,7 @@ class MimeControllerTest < ActionController::TestCase
     assert_equal '<html><div id="html_missing">Hello future from Firefox!</div></html>', @response.body
 
     @request.accept = "text/iphone"
-    assert_raises(ActionView::MissingTemplate) { get :iphone_with_html_response_type_without_layout }
+    assert_raise(ActionView::MissingTemplate) { get :iphone_with_html_response_type_without_layout }
   end
 end
 
diff --git a/actionpack/test/controller/redirect_test.rb b/actionpack/test/controller/redirect_test.rb
index 27cedc91d2..91e21db854 100644
--- a/actionpack/test/controller/redirect_test.rb
+++ b/actionpack/test/controller/redirect_test.rb
@@ -212,7 +212,7 @@ class RedirectTest < ActionController::TestCase
   end
 
   def test_redirect_to_back_with_no_referer
-    assert_raises(ActionController::RedirectBackError) {
+    assert_raise(ActionController::RedirectBackError) {
       @request.env["HTTP_REFERER"] = nil
       get :redirect_to_back
     }
@@ -239,7 +239,7 @@ class RedirectTest < ActionController::TestCase
   end
 
   def test_redirect_to_nil
-    assert_raises(ActionController::ActionControllerError) do
+    assert_raise(ActionController::ActionControllerError) do
       get :redirect_to_nil
     end
   end
diff --git a/actionpack/test/controller/render_test.rb b/actionpack/test/controller/render_test.rb
index e0b3f64b76..af623395f0 100644
--- a/actionpack/test/controller/render_test.rb
+++ b/actionpack/test/controller/render_test.rb
@@ -937,11 +937,11 @@ class RenderTest < ActionController::TestCase
   end
 
   def test_attempt_to_access_object_method
-    assert_raises(ActionController::UnknownAction, "No action responded to [clone]") { get :clone }
+    assert_raise(ActionController::UnknownAction, "No action responded to [clone]") { get :clone }
   end
 
   def test_private_methods
-    assert_raises(ActionController::UnknownAction, "No action responded to [determine_layout]") { get :determine_layout }
+    assert_raise(ActionController::UnknownAction, "No action responded to [determine_layout]") { get :determine_layout }
   end
 
   def test_access_to_request_in_view
@@ -1173,7 +1173,7 @@ class RenderTest < ActionController::TestCase
   end
 
   def test_bad_render_to_string_still_throws_exception
-    assert_raises(ActionView::MissingTemplate) { get :render_to_string_with_exception }
+    assert_raise(ActionView::MissingTemplate) { get :render_to_string_with_exception }
   end
 
   def test_render_to_string_that_throws_caught_exception_doesnt_break_assigns
@@ -1198,15 +1198,15 @@ class RenderTest < ActionController::TestCase
   end
 
   def test_double_render
-    assert_raises(ActionController::DoubleRenderError) { get :double_render }
+    assert_raise(ActionController::DoubleRenderError) { get :double_render }
   end
 
   def test_double_redirect
-    assert_raises(ActionController::DoubleRenderError) { get :double_redirect }
+    assert_raise(ActionController::DoubleRenderError) { get :double_redirect }
   end
 
   def test_render_and_redirect
-    assert_raises(ActionController::DoubleRenderError) { get :render_and_redirect }
+    assert_raise(ActionController::DoubleRenderError) { get :render_and_redirect }
   end
 
   # specify the one exception to double render rule - render_to_string followed by render
@@ -1515,7 +1515,7 @@ class RenderTest < ActionController::TestCase
   end
 
   def test_render_missing_partial_template
-    assert_raises(ActionView::MissingTemplate) do
+    assert_raise(ActionView::MissingTemplate) do
       get :missing_partial
     end
   end
diff --git a/actionpack/test/controller/request_forgery_protection_test.rb b/actionpack/test/controller/request_forgery_protection_test.rb
index ef0bf5fd08..835e73e3ab 100644
--- a/actionpack/test/controller/request_forgery_protection_test.rb
+++ b/actionpack/test/controller/request_forgery_protection_test.rb
@@ -79,17 +79,17 @@ module RequestForgeryProtectionTests
 
   def test_should_not_allow_html_post_without_token
     @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
-    assert_raises(ActionController::InvalidAuthenticityToken) { post :index, :format => :html }
+    assert_raise(ActionController::InvalidAuthenticityToken) { post :index, :format => :html }
   end
   
   def test_should_not_allow_html_put_without_token
     @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
-    assert_raises(ActionController::InvalidAuthenticityToken) { put :index, :format => :html }
+    assert_raise(ActionController::InvalidAuthenticityToken) { put :index, :format => :html }
   end
   
   def test_should_not_allow_html_delete_without_token
     @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
-    assert_raises(ActionController::InvalidAuthenticityToken) { delete :index, :format => :html }
+    assert_raise(ActionController::InvalidAuthenticityToken) { delete :index, :format => :html }
   end
 
   def test_should_allow_api_formatted_post_without_token
@@ -111,42 +111,42 @@ module RequestForgeryProtectionTests
   end
 
   def test_should_not_allow_api_formatted_post_sent_as_url_encoded_form_without_token
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raise(ActionController::InvalidAuthenticityToken) do
       @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
       post :index, :format => 'xml'
     end
   end
 
   def test_should_not_allow_api_formatted_put_sent_as_url_encoded_form_without_token
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raise(ActionController::InvalidAuthenticityToken) do
       @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
       put :index, :format => 'xml'
     end
   end
 
   def test_should_not_allow_api_formatted_delete_sent_as_url_encoded_form_without_token
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raise(ActionController::InvalidAuthenticityToken) do
       @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
       delete :index, :format => 'xml'
     end
   end
 
   def test_should_not_allow_api_formatted_post_sent_as_multipart_form_without_token
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raise(ActionController::InvalidAuthenticityToken) do
       @request.env['CONTENT_TYPE'] = Mime::MULTIPART_FORM.to_s
       post :index, :format => 'xml'
     end
   end
 
   def test_should_not_allow_api_formatted_put_sent_as_multipart_form_without_token
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raise(ActionController::InvalidAuthenticityToken) do
       @request.env['CONTENT_TYPE'] = Mime::MULTIPART_FORM.to_s
       put :index, :format => 'xml'
     end
   end
 
   def test_should_not_allow_api_formatted_delete_sent_as_multipart_form_without_token
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raise(ActionController::InvalidAuthenticityToken) do
       @request.env['CONTENT_TYPE'] = Mime::MULTIPART_FORM.to_s
       delete :index, :format => 'xml'
     end
diff --git a/actionpack/test/controller/request_test.rb b/actionpack/test/controller/request_test.rb
index efe4f136f5..c72f885a05 100644
--- a/actionpack/test/controller/request_test.rb
+++ b/actionpack/test/controller/request_test.rb
@@ -59,7 +59,7 @@ class RequestTest < ActiveSupport::TestCase
     assert_equal '3.4.5.6', @request.remote_ip
 
     @request.env['HTTP_CLIENT_IP'] = '8.8.8.8'
-    e = assert_raises(ActionController::ActionControllerError) {
+    e = assert_raise(ActionController::ActionControllerError) {
       @request.remote_ip
     }
     assert_match /IP spoofing attack/, e.message
@@ -297,7 +297,7 @@ class RequestTest < ActiveSupport::TestCase
   end
 
   def test_invalid_http_method_raises_exception
-    assert_raises(ActionController::UnknownHttpMethod) do
+    assert_raise(ActionController::UnknownHttpMethod) do
       self.request_method = :random_method
       @request.request_method
     end
@@ -311,7 +311,7 @@ class RequestTest < ActiveSupport::TestCase
   end
 
   def test_invalid_method_hacking_on_post_raises_exception
-    assert_raises(ActionController::UnknownHttpMethod) do
+    assert_raise(ActionController::UnknownHttpMethod) do
       self.request_method = :_random_method
       @request.request_method
     end
diff --git a/actionpack/test/controller/resources_test.rb b/actionpack/test/controller/resources_test.rb
index 17f6d99b21..35f943737f 100644
--- a/actionpack/test/controller/resources_test.rb
+++ b/actionpack/test/controller/resources_test.rb
@@ -99,7 +99,7 @@ class ResourcesTest < ActionController::TestCase
     expected_options = {:controller => 'messages', :action => 'show', :id => '1.1.1'}
 
     with_restful_routing :messages do
-      assert_raises(ActionController::RoutingError) do
+      assert_raise(ActionController::RoutingError) do
         assert_recognizes(expected_options, :path => 'messages/1.1.1', :method => :get)
       end
     end
@@ -333,7 +333,7 @@ class ResourcesTest < ActionController::TestCase
     with_restful_routing :messages do
       assert_restful_routes_for :messages do |options|
         assert_recognizes(options.merge(:action => "new"), :path => "/messages/new", :method => :get)
-        assert_raises(ActionController::MethodNotAllowed) do
+        assert_raise(ActionController::MethodNotAllowed) do
           ActionController::Routing::Routes.recognize_path("/messages/new", :method => :post)
         end
       end
@@ -619,11 +619,11 @@ class ResourcesTest < ActionController::TestCase
       options = { :controller => controller_name.to_s }
       collection_path = "/#{controller_name}"
 
-      assert_raises(ActionController::MethodNotAllowed) do
+      assert_raise(ActionController::MethodNotAllowed) do
         assert_recognizes(options.merge(:action => 'update'), :path => collection_path, :method => :put)
       end
 
-      assert_raises(ActionController::MethodNotAllowed) do
+      assert_raise(ActionController::MethodNotAllowed) do
         assert_recognizes(options.merge(:action => 'destroy'), :path => collection_path, :method => :delete)
       end
     end
@@ -632,7 +632,7 @@ class ResourcesTest < ActionController::TestCase
   def test_should_not_allow_invalid_head_method_for_member_routes
     with_routing do |set|
       set.draw do |map|
-        assert_raises(ArgumentError) do
+        assert_raise(ArgumentError) do
           map.resources :messages, :member => {:something => :head}
         end
       end
@@ -642,7 +642,7 @@ class ResourcesTest < ActionController::TestCase
   def test_should_not_allow_invalid_http_methods_for_member_routes
     with_routing do |set|
       set.draw do |map|
-        assert_raises(ArgumentError) do
+        assert_raise(ArgumentError) do
           map.resources :messages, :member => {:something => :invalid}
         end
       end
diff --git a/actionpack/test/controller/routing_test.rb b/actionpack/test/controller/routing_test.rb
index 55f3ad23be..8ed6b471ae 100644
--- a/actionpack/test/controller/routing_test.rb
+++ b/actionpack/test/controller/routing_test.rb
@@ -219,7 +219,7 @@ class DynamicSegmentTest < Test::Unit::TestCase
     a_value = nil
 
     # Local jump because of return inside eval.
-    assert_raises(LocalJumpError) { eval(segment.extraction_code) }
+    assert_raise(LocalJumpError) { eval(segment.extraction_code) }
   end
 
   def test_extraction_code_should_return_on_mismatch
@@ -229,7 +229,7 @@ class DynamicSegmentTest < Test::Unit::TestCase
     a_value = nil
 
     # Local jump because of return inside eval.
-    assert_raises(LocalJumpError) { eval(segment.extraction_code) }
+    assert_raise(LocalJumpError) { eval(segment.extraction_code) }
   end
 
   def test_extraction_code_should_accept_value_and_set_local
@@ -494,7 +494,7 @@ class RouteBuilderTest < Test::Unit::TestCase
     defaults = {:action => 'buy', :person => nil, :car => nil}
     requirements = {:person => /\w+/, :car => /^\w+$/}
 
-    assert_raises ArgumentError do
+    assert_raise ArgumentError do
       route_requirements = builder.assign_route_options(segments, defaults, requirements)
     end
 
@@ -882,7 +882,7 @@ class LegacyRouteSetTests < Test::Unit::TestCase
     end
     assert_equal({:controller => "admin/accounts", :action => "index"}, rs.recognize_path("/admin/accounts"))
     assert_equal({:controller => "admin/users", :action => "index"}, rs.recognize_path("/admin/users"))
-    assert_raises(ActionController::RoutingError) { rs.recognize_path("/admin/products") }
+    assert_raise(ActionController::RoutingError) { rs.recognize_path("/admin/products") }
   end
 
   def test_route_with_regexp_and_dot
@@ -1060,11 +1060,11 @@ class LegacyRouteSetTests < Test::Unit::TestCase
     rs.draw do |map|
       map.connect ':controller/:action/:id'
     end
-    assert_raises(ActionController::RoutingError) { rs.recognize_path("/not_a/show/10") }
+    assert_raise(ActionController::RoutingError) { rs.recognize_path("/not_a/show/10") }
   end
 
   def test_paths_do_not_accept_defaults
-    assert_raises(ActionController::RoutingError) do
+    assert_raise(ActionController::RoutingError) do
       rs.draw do |map|
         map.path 'file/*path', :controller => 'content', :action => 'show_file', :path => %w(fake default)
         map.connect ':controller/:action/:id'
@@ -1197,7 +1197,7 @@ class LegacyRouteSetTests < Test::Unit::TestCase
 
     assert_equal '/post/10', rs.generate(:controller => 'post', :action => 'show', :id => 10)
 
-    assert_raises ActionController::RoutingError do
+    assert_raise ActionController::RoutingError do
       rs.generate(:controller => 'post', :action => 'show')
     end
   end
@@ -1407,7 +1407,7 @@ class LegacyRouteSetTests < Test::Unit::TestCase
     end
 
     x = setup_for_named_route
-    assert_raises(ActionController::RoutingError) do
+    assert_raise(ActionController::RoutingError) do
       x.send(:foo_with_requirement_url, "I am Against the requirements")
     end
   end
@@ -1539,7 +1539,7 @@ class RouteTest < Test::Unit::TestCase
   end
 
   def test_builder_complains_without_controller
-    assert_raises(ArgumentError) do
+    assert_raise(ArgumentError) do
       ROUTING::RouteBuilder.new.build '/contact', :contoller => "contact", :action => "index"
     end
   end
@@ -1822,27 +1822,27 @@ class RouteSetTest < Test::Unit::TestCase
   end
 
   def test_route_requirements_with_anchor_chars_are_invalid
-    assert_raises ArgumentError do
+    assert_raise ArgumentError do
       set.draw do |map|
         map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /^\d+/
       end
     end
-    assert_raises ArgumentError do
+    assert_raise ArgumentError do
       set.draw do |map|
         map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\A\d+/
       end
     end
-    assert_raises ArgumentError do
+    assert_raise ArgumentError do
       set.draw do |map|
         map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+$/
       end
     end
-    assert_raises ArgumentError do
+    assert_raise ArgumentError do
       set.draw do |map|
         map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+\Z/
       end
     end
-    assert_raises ArgumentError do
+    assert_raise ArgumentError do
       set.draw do |map|
         map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+\z/
       end
@@ -1851,14 +1851,14 @@ class RouteSetTest < Test::Unit::TestCase
       set.draw do |map|
         map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+/, :name => /^(david|jamis)/
       end
-      assert_raises ActionController::RoutingError do
+      assert_raise ActionController::RoutingError do
         set.generate :controller => 'pages', :action => 'show', :id => 10
       end
     end
   end
 
   def test_route_requirements_with_invalid_http_method_is_invalid
-    assert_raises ArgumentError do
+    assert_raise ArgumentError do
       set.draw do |map|
         map.connect 'valid/route', :controller => 'pages', :action => 'show', :conditions => {:method => :invalid}
       end
@@ -1874,7 +1874,7 @@ class RouteSetTest < Test::Unit::TestCase
   end
 
   def test_route_requirements_with_head_method_condition_is_invalid
-    assert_raises ArgumentError do
+    assert_raise ArgumentError do
       set.draw do |map|
         map.connect 'valid/route', :controller => 'pages', :action => 'show', :conditions => {:method => :head}
       end
@@ -1886,10 +1886,10 @@ class RouteSetTest < Test::Unit::TestCase
       map.connect 'page/37s', :controller => 'pages', :action => 'show', :name => /(jamis|david)/
     end
     assert_equal '/page/37s', set.generate(:controller => 'pages', :action => 'show', :name => 'jamis')
-    assert_raises ActionController::RoutingError do
+    assert_raise ActionController::RoutingError do
       set.generate(:controller => 'pages', :action => 'show', :name => 'not_jamis')
     end
-    assert_raises ActionController::RoutingError do
+    assert_raise ActionController::RoutingError do
       set.generate(:controller => 'pages', :action => 'show', :name => 'nor_jamis_and_david')
     end
   end
@@ -1932,7 +1932,7 @@ class RouteSetTest < Test::Unit::TestCase
     assert_equal("update", request.path_parameters[:action])
     request.recycle!
 
-    assert_raises(ActionController::UnknownHttpMethod) {
+    assert_raise(ActionController::UnknownHttpMethod) {
       request.env["REQUEST_METHOD"] = "BACON"
       set.recognize(request)
     }
@@ -2317,7 +2317,7 @@ class RouteSetTest < Test::Unit::TestCase
   end
 
   def test_route_requirements_with_unsupported_regexp_options_must_error
-    assert_raises ArgumentError do
+    assert_raise ArgumentError do
       set.draw do |map|
         map.connect 'page/:name', :controller => 'pages',
           :action => 'show',
@@ -2355,7 +2355,7 @@ class RouteSetTest < Test::Unit::TestCase
         :requirements => {:name => /(david|jamis)/i}
     end
     assert_equal({:controller => 'pages', :action => 'show', :name => 'jamis'}, set.recognize_path('/page/jamis'))
-    assert_raises ActionController::RoutingError do
+    assert_raise ActionController::RoutingError do
       set.recognize_path('/page/davidjamis')
     end
     assert_equal({:controller => 'pages', :action => 'show', :name => 'DAVID'}, set.recognize_path('/page/DAVID'))
@@ -2369,7 +2369,7 @@ class RouteSetTest < Test::Unit::TestCase
     end
     url = set.generate({:controller => 'pages', :action => 'show', :name => 'david'})
     assert_equal "/page/david", url
-    assert_raises ActionController::RoutingError do
+    assert_raise ActionController::RoutingError do
       url = set.generate({:controller => 'pages', :action => 'show', :name => 'davidjamis'})
     end
     url = set.generate({:controller => 'pages', :action => 'show', :name => 'JAMIS'})
@@ -2389,10 +2389,10 @@ class RouteSetTest < Test::Unit::TestCase
     end
     assert_equal({:controller => 'pages', :action => 'show', :name => 'jamis'}, set.recognize_path('/page/jamis'))
     assert_equal({:controller => 'pages', :action => 'show', :name => 'david'}, set.recognize_path('/page/david'))
-    assert_raises ActionController::RoutingError do
+    assert_raise ActionController::RoutingError do
       set.recognize_path('/page/david #The Creator')
     end
-    assert_raises ActionController::RoutingError do
+    assert_raise ActionController::RoutingError do
       set.recognize_path('/page/David')
     end
   end
@@ -2410,10 +2410,10 @@ class RouteSetTest < Test::Unit::TestCase
     end
     url = set.generate({:controller => 'pages', :action => 'show', :name => 'david'})
     assert_equal "/page/david", url
-    assert_raises ActionController::RoutingError do
+    assert_raise ActionController::RoutingError do
       url = set.generate({:controller => 'pages', :action => 'show', :name => 'davidjamis'})
     end
-    assert_raises ActionController::RoutingError do
+    assert_raise ActionController::RoutingError do
       url = set.generate({:controller => 'pages', :action => 'show', :name => 'JAMIS'})
     end
   end
diff --git a/actionpack/test/controller/selector_test.rb b/actionpack/test/controller/selector_test.rb
index 4e31b4573c..9d0613d1e2 100644
--- a/actionpack/test/controller/selector_test.rb
+++ b/actionpack/test/controller/selector_test.rb
@@ -303,7 +303,7 @@ class SelectorTest < Test::Unit::TestCase
     assert_equal 1, @matches.size
     assert_equal "2", @matches[0].attributes["id"]
     # Before first and past last returns nothing.:
-    assert_raises(ArgumentError) { select("tr:nth-child(-1)") }
+    assert_raise(ArgumentError) { select("tr:nth-child(-1)") }
     select("tr:nth-child(0)")
     assert_equal 0, @matches.size
     select("tr:nth-child(5)")
@@ -597,8 +597,8 @@ class SelectorTest < Test::Unit::TestCase
 
   def test_negation_details
     parse(%Q{<p id="1"></p><p id="2"></p><p id="3"></p>})
-    assert_raises(ArgumentError) { select(":not(") }
-    assert_raises(ArgumentError) { select(":not(:not())") }
+    assert_raise(ArgumentError) { select(":not(") }
+    assert_raise(ArgumentError) { select(":not(:not())") }
     select("p:not(#1):not(#3)")
     assert_equal 1, @matches.size
     assert_equal "2", @matches[0].attributes["id"]
diff --git a/actionpack/test/controller/send_file_test.rb b/actionpack/test/controller/send_file_test.rb
index 5fc79baa44..a27e951929 100644
--- a/actionpack/test/controller/send_file_test.rb
+++ b/actionpack/test/controller/send_file_test.rb
@@ -142,7 +142,7 @@ class SendFileTest < ActionController::TestCase
     }
 
     @controller.headers = {}
-    assert_raises(ArgumentError){ @controller.send(:send_file_headers!, options) }
+    assert_raise(ArgumentError){ @controller.send(:send_file_headers!, options) }
   end
 
   %w(file data).each do |method|
diff --git a/actionpack/test/controller/url_rewriter_test.rb b/actionpack/test/controller/url_rewriter_test.rb
index 09a8356fec..863f8414c5 100644
--- a/actionpack/test/controller/url_rewriter_test.rb
+++ b/actionpack/test/controller/url_rewriter_test.rb
@@ -99,7 +99,7 @@ class UrlWriterTests < ActionController::TestCase
   end
 
   def test_exception_is_thrown_without_host
-    assert_raises RuntimeError do
+    assert_raise RuntimeError do
       W.new.url_for :controller => 'c', :action => 'a', :id => 'i'
     end
   end