mechanize 2.0 → 2.0.1

data/test/test_mechanize_cookie.rb

@@ -17,7 +17,7 @@ module Enumerable
   end
 end
 
-class TestMechanizeCookie < Test::Unit::TestCase
+class TestMechanizeCookie < MiniTest::Unit::TestCase
   def silently
     warn_level = $VERBOSE
     $VERBOSE = false
@@ -183,7 +183,7 @@ class TestMechanizeCookie < Test::Unit::TestCase
       end
       cookie = nil
       Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
-      assert_not_nil(cookie)
+
       assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
       assert_equal('/', cookie.path)
 
@@ -218,7 +218,7 @@ class TestMechanizeCookie < Test::Unit::TestCase
       end
       cookie = nil
       Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
-      assert_not_nil(cookie)
+
       assert_equal('12345%7D=', cookie.to_s)
       assert_equal('', cookie.value)
       assert_equal('/', cookie.path)
@@ -256,7 +256,7 @@ class TestMechanizeCookie < Test::Unit::TestCase
       end
       cookie = nil
       Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
-      assert_not_nil(cookie)
+
       assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
       assert_equal('/', cookie.path)
 
@@ -293,7 +293,7 @@ class TestMechanizeCookie < Test::Unit::TestCase
       end
       cookie = nil
       Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
-      assert_not_nil(cookie)
+
       assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
       assert_equal('/', cookie.path)
       assert_equal(true, cookie.secure)
@@ -329,7 +329,7 @@ class TestMechanizeCookie < Test::Unit::TestCase
       end
       cookie = nil
       Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
-      assert_not_nil(cookie)
+
       assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
       assert_equal('/', cookie.path)
 

data/test/test_mechanize_cookie_jar.rb

@@ -1,7 +1,7 @@
 require 'helper'
 require 'tmpdir'
 
-class TestMechanizeCookieJar < Test::Unit::TestCase
+class TestMechanizeCookieJar < MiniTest::Unit::TestCase
 
   def setup
     @jar = Mechanize::CookieJar.new
@@ -378,9 +378,10 @@ class TestMechanizeCookieJar < Test::Unit::TestCase
 
     @jar.jar['rubyforge.org'] = {}
 
-    assert_nothing_raised do
-      @jar.add(url, cookie_from_hash(cookie_values))
-    end
+
+    @jar.add url, cookie_from_hash(cookie_values)
+
+    # HACK no asertion
   end
 
   def test_ssl_cookies

data/test/test_mechanize_file.rb

@@ -1,6 +1,6 @@
 require "helper"
 
-class TestMechanizeFile < Test::Unit::TestCase
+class TestMechanizeFile < MiniTest::Unit::TestCase
   def test_content_disposition
     file = Mechanize::File.new(
                                     URI.parse('http://localhost/foo'),

data/test/test_mechanize_file_request.rb

@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestMechanizeFileRequest < Test::Unit::TestCase
+class TestMechanizeFileRequest < MiniTest::Unit::TestCase
 
   def test_initialize
     uri = URI.parse 'http://example/'

data/test/test_mechanize_file_response.rb

@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestMechanizeFileConnection < Test::Unit::TestCase
+class TestMechanizeFileConnection < MiniTest::Unit::TestCase
 
   def test_request
     uri = URI.parse "file://#{File.expand_path __FILE__}"

data/test/test_mechanize_form.rb

@@ -1,6 +1,6 @@
 require "helper"
 
-class TestMechanizeForm < Test::Unit::TestCase
+class TestMechanizeForm < MiniTest::Unit::TestCase
 
   def setup
     @agent = Mechanize.new
@@ -24,10 +24,10 @@ class TestMechanizeForm < Test::Unit::TestCase
   def test_field_with
     page = @agent.get("http://localhost/google.html")
     search = page.forms.find { |f| f.name == "f" }
-    assert_not_nil(search)
-    assert_not_nil(search.field_with(:name => 'q'))
-    assert_not_nil(search.field_with(:name => 'hl'))
-    assert_not_nil(search.fields.find { |f| f.name == 'ie' })
+
+    assert(search.field_with(:name => 'q'))
+    assert(search.field_with(:name => 'hl'))
+    assert(search.fields.find { |f| f.name == 'ie' })
   end
 
   def test_fields_no_input_name
@@ -114,7 +114,6 @@ class TestMechanizeForm < Test::Unit::TestCase
     page = @agent.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'post_form')
 
-    assert_not_nil(form)
     assert_equal(2, form.fields_with(:name => 'first').length)
 
     form.fields_with(:name => 'first')[0].value = 'Aaron'
@@ -122,11 +121,9 @@ class TestMechanizeForm < Test::Unit::TestCase
 
     page = @agent.submit(form)
 
-    assert_not_nil(page)
-
     assert_equal(2, page.links.length)
-    assert_not_nil(page.link_with(:text => 'first:Aaron'))
-    assert_not_nil(page.link_with(:text => 'first:Patterson'))
+    assert(page.link_with(:text => 'first:Aaron'))
+    assert(page.link_with(:text => 'first:Patterson'))
   end
 
   # Test calling submit on the form object
@@ -134,7 +131,6 @@ class TestMechanizeForm < Test::Unit::TestCase
     page = @agent.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'post_form')
 
-    assert_not_nil(form)
     assert_equal(2, form.fields_with(:name => 'first').length)
 
     form.fields_with(:name => 'first')[0].value = 'Aaron'
@@ -142,11 +138,9 @@ class TestMechanizeForm < Test::Unit::TestCase
 
     page = form.submit
 
-    assert_not_nil(page)
-
     assert_equal(2, page.links.length)
-    assert_not_nil(page.link_with(:text => 'first:Aaron'))
-    assert_not_nil(page.link_with(:text => 'first:Patterson'))
+    assert(page.link_with(:text => 'first:Aaron'))
+    assert(page.link_with(:text => 'first:Patterson'))
   end
 
   # Test submitting form with two fields of the same name
@@ -154,7 +148,6 @@ class TestMechanizeForm < Test::Unit::TestCase
     page = @agent.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'get_form')
 
-    assert_not_nil(form)
     assert_equal(2, form.fields_with(:name => 'first').length)
 
     form.fields_with(:name => 'first')[0].value = 'Aaron'
@@ -162,11 +155,9 @@ class TestMechanizeForm < Test::Unit::TestCase
 
     page = @agent.submit(form)
 
-    assert_not_nil(page)
-
     assert_equal(2, page.links.length)
-    assert_not_nil(page.link_with(:text => 'first:Aaron'))
-    assert_not_nil(page.link_with(:text => 'first:Patterson'))
+    assert(page.link_with(:text => 'first:Aaron'))
+    assert(page.link_with(:text => 'first:Patterson'))
   end
 
   def test_post_with_non_strings
@@ -179,7 +170,7 @@ class TestMechanizeForm < Test::Unit::TestCase
   def test_post
     page = @agent.get("http://localhost/form_test.html")
     post_form = page.forms.find { |f| f.name == "post_form1" }
-    assert_not_nil(post_form, "Post form is null")
+
     assert_equal("post", post_form.method.downcase)
     assert_equal("/form_post", post_form.action)
 
@@ -188,28 +179,22 @@ class TestMechanizeForm < Test::Unit::TestCase
     assert_equal(1, post_form.buttons.size)
     assert_equal(2, post_form.radiobuttons.size)
     assert_equal(3, post_form.checkboxes.size)
-    assert_not_nil(post_form.fields.find { |f| f.name == "first_name" },
-      "First name field was nil"
-    )
-    assert_not_nil(post_form.fields.find { |f| f.name == "country" },
-      "Country field was nil"
-    )
-    assert_not_nil(
-    post_form.radiobuttons.find { |f| f.name == "gender" && f.value == "male"},
-      "Gender male button was nil"
-    )
-
-    assert_not_nil(
-    post_form.radiobuttons.find {|f| f.name == "gender" && f.value == "female"},
-      "Gender female button was nil"
-    )
-
-    assert_not_nil(post_form.checkboxes.find { |f| f.name == "cool person" },
-      "couldn't find cool person checkbox")
-    assert_not_nil(post_form.checkboxes.find { |f| f.name == "likes ham" },
-      "couldn't find likes ham checkbox")
-    assert_not_nil(post_form.checkboxes.find { |f| f.name == "green[eggs]" },
-      "couldn't find green[eggs] checkbox")
+    assert(post_form.fields.find { |f| f.name == "first_name" },
+           "First name field was nil")
+    assert(post_form.fields.find { |f| f.name == "country" },
+           "Country field was nil")
+    assert(post_form.radiobuttons.find { |f| f.name == "gender" && f.value == "male"},
+           "Gender male button was nil")
+
+    assert(post_form.radiobuttons.find {|f| f.name == "gender" && f.value == "female"},
+           "Gender female button was nil")
+
+    assert(post_form.checkboxes.find { |f| f.name == "cool person" },
+           "couldn't find cool person checkbox")
+    assert(post_form.checkboxes.find { |f| f.name == "likes ham" },
+           "couldn't find likes ham checkbox")
+    assert(post_form.checkboxes.find { |f| f.name == "green[eggs]" },
+           "couldn't find green[eggs] checkbox")
 
     # Find the select list
     s = post_form.fields.find { |f| f.name == "country" }
@@ -231,32 +216,22 @@ class TestMechanizeForm < Test::Unit::TestCase
 
     # Check that the submitted fields exist
     assert_equal(5, page.links.size, "Not enough links")
-    assert_not_nil(
-      page.links.find { |l| l.text == "likes ham:on" },
-      "likes ham check box missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "green[eggs]:on" },
-      "green[eggs] check box missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "first_name:Aaron" },
-      "first_name field missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "gender:male" },
-      "gender field missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "country:USA" },
-      "select box not submitted"
-    )
+    assert(page.links.find { |l| l.text == "likes ham:on" },
+           "likes ham check box missing")
+    assert(page.links.find { |l| l.text == "green[eggs]:on" },
+           "green[eggs] check box missing")
+    assert(page.links.find { |l| l.text == "first_name:Aaron" },
+           "first_name field missing")
+    assert(page.links.find { |l| l.text == "gender:male" },
+           "gender field missing")
+    assert(page.links.find { |l| l.text == "country:USA" },
+           "select box not submitted")
   end
 
   def test_post_multipart
     page = @agent.get("http://localhost/form_test.html")
     post_form = page.forms.find { |f| f.name == "post_form4_multipart" }
-    assert_not_nil(post_form, "Post form is null")
+    assert(post_form, "Post form is null")
     assert_equal("post", post_form.method.downcase)
     assert_equal("/form_post", post_form.action)
 
@@ -265,22 +240,22 @@ class TestMechanizeForm < Test::Unit::TestCase
 
     page = @agent.submit(post_form, post_form.buttons.first)
 
-    assert_not_nil(page)
+    assert page
   end
 
   def test_select_box
     page = @agent.get("http://localhost/form_test.html")
     post_form = page.forms.find { |f| f.name == "post_form1" }
-    assert_not_nil(post_form, "Post form is null")
-    assert_not_nil(page.header)
-    assert_not_nil(page.root)
+
+    assert(page.header)
+    assert(page.root)
     assert_equal(0, page.iframes.length)
     assert_equal("post", post_form.method.downcase)
     assert_equal("/form_post", post_form.action)
 
     # Find the select list
     s = post_form.field_with(:name => /country/)
-    assert_not_nil(s, "Couldn't find country select list")
+
     assert_equal(2, s.options.length)
     assert_equal("USA", s.value)
     assert_equal("USA", s.options.first.value)
@@ -294,41 +269,34 @@ class TestMechanizeForm < Test::Unit::TestCase
     page = @agent.submit(post_form, post_form.buttons.first)
 
     # Check that the submitted fields exist
-    assert_not_nil(
-      page.links.find { |l| l.text == "country:CANADA" },
-      "select box not submitted"
-    )
+    assert(page.links.find { |l| l.text == "country:CANADA" },
+           "select box not submitted")
   end
 
   def test_get
     page = @agent.get("http://localhost/form_test.html")
     get_form = page.forms.find { |f| f.name == "get_form1" }
-    assert_not_nil(get_form, "Get form is null")
+
     assert_equal("get", get_form.method.downcase)
     assert_equal("/form_post", get_form.action)
     assert_equal(1, get_form.fields.size)
     assert_equal(2, get_form.buttons.size)
     assert_equal(2, get_form.radiobuttons.size)
     assert_equal(3, get_form.checkboxes.size)
-    assert_not_nil(get_form.fields.find { |f| f.name == "first_name" },
-      "First name field was nil"
-    )
-    assert_not_nil(
-    get_form.radiobuttons.find { |f| f.name == "gender" && f.value == "male"},
-      "Gender male button was nil"
-    )
-
-    assert_not_nil(
-    get_form.radiobuttons.find {|f| f.name == "gender" && f.value == "female"},
-      "Gender female button was nil"
-    )
-
-    assert_not_nil(get_form.checkboxes.find { |f| f.name == "cool person" },
-      "couldn't find cool person checkbox")
-    assert_not_nil(get_form.checkboxes.find { |f| f.name == "likes ham" },
-      "couldn't find likes ham checkbox")
-    assert_not_nil(get_form.checkboxes.find { |f| f.name == "green[eggs]" },
-      "couldn't find green[eggs] checkbox")
+    assert(get_form.fields.find { |f| f.name == "first_name" },
+           "First name field was nil")
+    assert(get_form.radiobuttons.find { |f| f.name == "gender" && f.value == "male"},
+           "Gender male button was nil")
+
+    assert(get_form.radiobuttons.find {|f| f.name == "gender" && f.value == "female"},
+           "Gender female button was nil")
+
+    assert(get_form.checkboxes.find { |f| f.name == "cool person" },
+           "couldn't find cool person checkbox")
+    assert(get_form.checkboxes.find { |f| f.name == "likes ham" },
+           "couldn't find likes ham checkbox")
+    assert(get_form.checkboxes.find { |f| f.name == "green[eggs]" },
+           "couldn't find green[eggs] checkbox")
 
     # Set up the image button
     img = get_form.buttons.find { |f| f.name == "button" }
@@ -345,59 +313,42 @@ class TestMechanizeForm < Test::Unit::TestCase
 
     # Check that the submitted fields exist
     assert_equal(6, page.links.size, "Not enough links")
-    assert_not_nil(
-      page.links.find { |l| l.text == "likes ham:on" },
-      "likes ham check box missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "green[eggs]:on" },
-      "green[eggs] check box missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "first_name:Aaron" },
-      "first_name field missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "gender:male" },
-      "gender field missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "button.y:10" },
-      "Image button missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "button.x:9" },
-      "Image button missing"
-    )
+    assert(page.links.find { |l| l.text == "likes ham:on" },
+           "likes ham check box missing")
+    assert(page.links.find { |l| l.text == "green[eggs]:on" },
+           "green[eggs] check box missing")
+    assert(page.links.find { |l| l.text == "first_name:Aaron" },
+           "first_name field missing")
+    assert(page.links.find { |l| l.text == "gender:male" },
+           "gender field missing")
+    assert(page.links.find { |l| l.text == "button.y:10" },
+           "Image button missing")
+    assert(page.links.find { |l| l.text == "button.x:9" },
+           "Image button missing")
   end
 
   def test_post_with_space_in_action
     page = @agent.get("http://localhost/form_test.html")
     post_form = page.forms.find { |f| f.name == "post_form2" }
-    assert_not_nil(post_form, "Post form is null")
+
     assert_equal("post", post_form.method.downcase)
     assert_equal("/form post", post_form.action)
     assert_equal(1, post_form.fields.size)
     assert_equal(1, post_form.buttons.size)
     assert_equal(2, post_form.radiobuttons.size)
     assert_equal(2, post_form.checkboxes.size)
-    assert_not_nil(post_form.fields.find { |f| f.name == "first_name" },
-      "First name field was nil"
-    )
-    assert_not_nil(
-    post_form.radiobuttons.find { |f| f.name == "gender" && f.value == "male"},
-      "Gender male button was nil"
-    )
-
-    assert_not_nil(
-    post_form.radiobuttons.find {|f| f.name == "gender" && f.value == "female"},
-      "Gender female button was nil"
-    )
-
-    assert_not_nil(post_form.checkboxes.find { |f| f.name == "cool person" },
-      "couldn't find cool person checkbox")
-    assert_not_nil(post_form.checkboxes.find { |f| f.name == "likes ham" },
-      "couldn't find likes ham checkbox")
+    assert(post_form.fields.find { |f| f.name == "first_name" },
+           "First name field was nil")
+    assert(post_form.radiobuttons.find { |f| f.name == "gender" && f.value == "male"},
+           "Gender male button was nil")
+
+    assert(post_form.radiobuttons.find {|f| f.name == "gender" && f.value == "female"},
+           "Gender female button was nil")
+
+    assert(post_form.checkboxes.find { |f| f.name == "cool person" },
+           "couldn't find cool person checkbox")
+    assert(post_form.checkboxes.find { |f| f.name == "likes ham" },
+           "couldn't find likes ham checkbox")
 
     # Now set all the fields
     post_form.fields.find { |f| f.name == "first_name" }.value = "Aaron"
@@ -409,47 +360,36 @@ class TestMechanizeForm < Test::Unit::TestCase
 
     # Check that the submitted fields exist
     assert_equal(3, page.links.size, "Not enough links")
-    assert_not_nil(
-      page.links.find { |l| l.text == "likes ham:on" },
-      "likes ham check box missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "first_name:Aaron" },
-      "first_name field missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "gender:male" },
-      "gender field missing"
-    )
+    assert(page.links.find { |l| l.text == "likes ham:on" },
+           "likes ham check box missing")
+    assert(page.links.find { |l| l.text == "first_name:Aaron" },
+           "first_name field missing")
+    assert(page.links.find { |l| l.text == "gender:male" },
+           "gender field missing")
   end
 
   def test_get_with_space_in_action
     page = @agent.get("http://localhost/form_test.html")
     get_form = page.forms.find { |f| f.name == "get_form2" }
-    assert_not_nil(get_form, "Get form is null")
+
     assert_equal("get", get_form.method.downcase)
     assert_equal("/form post", get_form.action)
     assert_equal(1, get_form.fields.size)
     assert_equal(1, get_form.buttons.size)
     assert_equal(2, get_form.radiobuttons.size)
     assert_equal(2, get_form.checkboxes.size)
-    assert_not_nil(get_form.fields.find { |f| f.name == "first_name" },
-      "First name field was nil"
-    )
-    assert_not_nil(
-    get_form.radiobuttons.find { |f| f.name == "gender" && f.value == "male"},
-      "Gender male button was nil"
-    )
-
-    assert_not_nil(
-    get_form.radiobuttons.find {|f| f.name == "gender" && f.value == "female"},
-      "Gender female button was nil"
-    )
-
-    assert_not_nil(get_form.checkboxes.find { |f| f.name == "cool person" },
-      "couldn't find cool person checkbox")
-    assert_not_nil(get_form.checkboxes.find { |f| f.name == "likes ham" },
-      "couldn't find likes ham checkbox")
+    assert(get_form.fields.find { |f| f.name == "first_name" },
+           "First name field was nil")
+    assert(get_form.radiobuttons.find { |f| f.name == "gender" && f.value == "male"},
+           "Gender male button was nil")
+
+    assert(get_form.radiobuttons.find {|f| f.name == "gender" && f.value == "female"},
+           "Gender female button was nil")
+
+    assert(get_form.checkboxes.find { |f| f.name == "cool person" },
+           "couldn't find cool person checkbox")
+    assert(get_form.checkboxes.find { |f| f.name == "likes ham" },
+           "couldn't find likes ham checkbox")
 
     # Now set all the fields
     get_form.fields.find { |f| f.name == "first_name" }.value = "Aaron"
@@ -461,24 +401,18 @@ class TestMechanizeForm < Test::Unit::TestCase
 
     # Check that the submitted fields exist
     assert_equal(3, page.links.size, "Not enough links")
-    assert_not_nil(
-      page.links.find { |l| l.text == "likes ham:on" },
-      "likes ham check box missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "first_name:Aaron" },
-      "first_name field missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "gender:male" },
-      "gender field missing"
-    )
+    assert(page.links.find { |l| l.text == "likes ham:on" },
+           "likes ham check box missing")
+    assert(page.links.find { |l| l.text == "first_name:Aaron" },
+           "first_name field missing")
+    assert(page.links.find { |l| l.text == "gender:male" },
+           "gender field missing")
   end
 
   def test_post_with_param_in_action
     page = @agent.get("http://localhost/form_test.html")
     post_form = page.forms.find { |f| f.name == "post_form3" }
-    assert_not_nil(post_form, "Post form is null")
+
     assert_equal("post", post_form.method.downcase)
     assert_equal("/form_post?great day=yes&one=two", post_form.action)
     assert_equal(1, post_form.fields.size)
@@ -486,24 +420,24 @@ class TestMechanizeForm < Test::Unit::TestCase
     assert_equal(2, post_form.radiobuttons.size)
     assert_equal(2, post_form.checkboxes.size)
 
-    assert_not_nil(post_form.fields.find { |f| f.name == "first_name" },
-                   "First name field was nil")
+    assert(post_form.fields.find { |f| f.name == "first_name" },
+           "First name field was nil")
 
     male_button = post_form.radiobuttons.find { |f|
       f.name == "gender" && f.value == "male"
     }
-    assert_not_nil(male_button, "Gender male button was nil")
+    assert(male_button, "Gender male button was nil")
 
     female_button = post_form.radiobuttons.find { |f|
       f.name == "gender" && f.value == "female"
     }
 
-    assert_not_nil(female_button, "Gender female button was nil")
+    assert(female_button, "Gender female button was nil")
 
-    assert_not_nil(post_form.checkbox_with(:name => "cool person"),
-                   "couldn't find cool person checkbox")
+    assert(post_form.checkbox_with(:name => "cool person"),
+           "couldn't find cool person checkbox")
 
-    assert_not_nil(post_form.checkboxes.find { |f| f.name == "likes ham" },
+    assert(post_form.checkboxes.find { |f| f.name == "likes ham" },
                    "couldn't find likes ham checkbox")
 
     # Now set all the fields
@@ -518,41 +452,36 @@ class TestMechanizeForm < Test::Unit::TestCase
     # Check that the submitted fields exist
     assert_equal(3, page.links.size, "Not enough links")
 
-    assert_not_nil(page.links.find { |l| l.text == "likes ham:on" },
-                   "likes ham check box missing")
-    assert_not_nil(page.links.find { |l| l.text == "first_name:Aaron" },
-                   "first_name field missing")
-    assert_not_nil(page.links.find { |l| l.text == "gender:male" },
-                   "gender field missing")
+    assert(page.links.find { |l| l.text == "likes ham:on" },
+           "likes ham check box missing")
+    assert(page.links.find { |l| l.text == "first_name:Aaron" },
+           "first_name field missing")
+    assert(page.links.find { |l| l.text == "gender:male" },
+           "gender field missing")
   end
 
   def test_get_with_param_in_action
     page = @agent.get("http://localhost/form_test.html")
     get_form = page.forms.find { |f| f.name == "get_form3" }
-    assert_not_nil(get_form, "Get form is null")
+
     assert_equal("get", get_form.method.downcase)
     assert_equal("/form_post?great day=yes&one=two", get_form.action)
     assert_equal(1, get_form.fields.size)
     assert_equal(1, get_form.buttons.size)
     assert_equal(2, get_form.radiobuttons.size)
     assert_equal(2, get_form.checkboxes.size)
-    assert_not_nil(get_form.fields.find { |f| f.name == "first_name" },
-      "First name field was nil"
-    )
-    assert_not_nil(
-    get_form.radiobuttons.find { |f| f.name == "gender" && f.value == "male"},
-      "Gender male button was nil"
-    )
-
-    assert_not_nil(
-    get_form.radiobuttons.find {|f| f.name == "gender" && f.value == "female"},
-      "Gender female button was nil"
-    )
-
-    assert_not_nil(get_form.checkboxes.find { |f| f.name == "cool person" },
-      "couldn't find cool person checkbox")
-    assert_not_nil(get_form.checkboxes.find { |f| f.name == "likes ham" },
-      "couldn't find likes ham checkbox")
+    assert(get_form.fields.find { |f| f.name == "first_name" },
+           "First name field was nil")
+    assert(get_form.radiobuttons.find { |f| f.name == "gender" && f.value == "male"},
+           "Gender male button was nil")
+
+    assert(get_form.radiobuttons.find {|f| f.name == "gender" && f.value == "female"},
+           "Gender female button was nil")
+
+    assert(get_form.checkboxes.find { |f| f.name == "cool person" },
+           "couldn't find cool person checkbox")
+    assert(get_form.checkboxes.find { |f| f.name == "likes ham" },
+           "couldn't find likes ham checkbox")
 
     # Now set all the fields
     get_form.fields.find { |f| f.name == "first_name" }.value = "Aaron"
@@ -563,18 +492,12 @@ class TestMechanizeForm < Test::Unit::TestCase
     page = @agent.submit(get_form, get_form.buttons.first)
     # Check that the submitted fields exist
     assert_equal(3, page.links.size, "Not enough links")
-    assert_not_nil(
-      page.links.find { |l| l.text == "likes ham:on" },
-      "likes ham check box missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "first_name:Aaron" },
-      "first_name field missing"
-    )
-    assert_not_nil(
-      page.links.find { |l| l.text == "gender:male" },
-      "gender field missing"
-    )
+    assert(page.links.find { |l| l.text == "likes ham:on" },
+           "likes ham check box missing")
+    assert(page.links.find { |l| l.text == "first_name:Aaron" },
+           "first_name field missing")
+    assert(page.links.find { |l| l.text == "gender:male" },
+           "gender field missing")
   end
 
   def test_field_addition
@@ -588,7 +511,6 @@ class TestMechanizeForm < Test::Unit::TestCase
     page = @agent.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'post_form')
 
-    assert_not_nil(form)
     assert_equal(2, form.fields_with(:name => 'first').length)
 
     form.first = 'Aaron'
@@ -601,8 +523,6 @@ class TestMechanizeForm < Test::Unit::TestCase
     form = page.form_with(:dom_id => 'generic_form')
     form_by_id = page.form_with(:id => 'generic_form')
 
-
-    assert_not_nil(form)
     assert_equal(1, form.fields_with(:dom_id => 'name_first').length)
     assert_equal('first_name', form.field_with(:dom_id => 'name_first').name)
 
@@ -615,11 +535,9 @@ class TestMechanizeForm < Test::Unit::TestCase
     page = @agent.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'post_form')
 
-    assert_not_nil(form)
     number_of_fields = form.fields.length
 
-    f = form.add_field!('intarweb')
-    assert_not_nil(f)
+    assert form.add_field!('intarweb')
     assert_equal(number_of_fields + 1, form.fields.length)
   end
 
@@ -627,7 +545,6 @@ class TestMechanizeForm < Test::Unit::TestCase
     page = @agent.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'post_form')
 
-    assert_not_nil(form)
     number_of_fields = form.fields.length
     assert_equal 2, number_of_fields
 
@@ -640,21 +557,19 @@ class TestMechanizeForm < Test::Unit::TestCase
     page = @agent.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'post_form')
 
-    assert_not_nil(form)
     assert(!form.has_field?('intarweb'))
-    f = form.add_field!('intarweb')
-    assert_not_nil(f)
+    assert form.add_field!('intarweb')
     assert(form.has_field?('intarweb'))
   end
 
   def test_field_error
     @page = @agent.get('http://localhost/empty_form.html')
     form = @page.forms.first
-    assert_raise(NoMethodError) {
+    assert_raises(NoMethodError) {
       form.foo = 'asdfasdf'
     }
 
-    assert_raise(NoMethodError) {
+    assert_raises(NoMethodError) {
       form.foo
     }
   end