mechanize 0.4.7 → 0.5.0

data/test/tc_cookies.rb

@@ -3,122 +3,119 @@ $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
 require 'test/unit'
 require 'rubygems'
 require 'mechanize'
-require 'net/http'
-require 'uri'
 require 'test_includes'
 
 class CookiesMechTest < Test::Unit::TestCase
   include TestMethods
 
+  def setup
+    @agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+  end
+
   def test_send_cookies
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/many_cookies")
-    page = agent.get("http://localhost:#{@port}/send_cookies")
+    page = @agent.get("http://localhost:#{PORT}/many_cookies")
+    page = @agent.get("http://localhost:#{PORT}/send_cookies")
     assert_equal(2, page.links.length)
     assert_not_nil(page.links.find { |l| l.text == "name:Aaron" })
     assert_not_nil(page.links.find { |l| l.text == "no_expires:nope" })
   end
 
   def test_no_space_cookies
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/one_cookie_no_space")
-    assert_equal(1, agent.cookies.length)
-    foo_cookie = agent.cookies.find { |k| k.name == 'foo' }
+    page = @agent.get("http://localhost:#{PORT}/one_cookie_no_space")
+    assert_equal(1, @agent.cookies.length)
+    foo_cookie = @agent.cookies.find { |k| k.name == 'foo' }
     assert_not_nil(foo_cookie, 'Foo cookie was nil')
     assert_equal('bar', foo_cookie.value)
     assert_equal('/', foo_cookie.path)
-    assert_equal(true, DateTime.now < foo_cookie.expires)
+    assert_equal(true, Time.now < foo_cookie.expires)
   end
 
   def test_many_cookies_as_string
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/many_cookies_as_string")
-    assert_equal(4, agent.cookies.length)
+    page = @agent.get("http://localhost:#{PORT}/many_cookies_as_string")
+    assert_equal(4, @agent.cookies.length)
 
-    name_cookie = agent.cookies.find { |k| k.name == "name" }
+    name_cookie = @agent.cookies.find { |k| k.name == "name" }
     assert_not_nil(name_cookie, "Name cookie was nil")
     assert_equal("Aaron", name_cookie.value)
     assert_equal("/", name_cookie.path)
-    assert_equal(true, DateTime.now < name_cookie.expires)
+    assert_equal(true, Time.now < name_cookie.expires)
 
-    expired_cookie = agent.cookies.find { |k| k.name == "expired" }
+    expired_cookie = @agent.cookies.find { |k| k.name == "expired" }
     assert_nil(expired_cookie, "Expired cookie was not nil")
 
-    no_exp_cookie = agent.cookies.find { |k| k.name == "no_expires" }
+    no_exp_cookie = @agent.cookies.find { |k| k.name == "no_expires" }
     assert_not_nil(no_exp_cookie, "No expires cookie is nil")
     assert_equal("nope", no_exp_cookie.value)
     assert_equal("/", no_exp_cookie.path)
     assert_nil(no_exp_cookie.expires)
 
-    path_cookie = agent.cookies.find { |k| k.name == "a_path" }
+    path_cookie = @agent.cookies.find { |k| k.name == "a_path" }
     assert_not_nil(path_cookie, "Path cookie is nil")
     assert_equal("some_path", path_cookie.value)
-    assert_equal(true, DateTime.now < path_cookie.expires)
+    assert_equal(true, Time.now < path_cookie.expires)
 
-    no_path_cookie = agent.cookies.find { |k| k.name == "no_path" }
+    no_path_cookie = @agent.cookies.find { |k| k.name == "no_path" }
     assert_not_nil(no_path_cookie, "No path cookie is nil")
     assert_equal("no_path", no_path_cookie.value)
     assert_equal("/many_cookies_as_string", no_path_cookie.path)
-    assert_equal(true, DateTime.now < no_path_cookie.expires)
+    assert_equal(true, Time.now < no_path_cookie.expires)
   end
 
   def test_many_cookies
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/many_cookies")
-    assert_equal(4, agent.cookies.length)
+    page = @agent.get("http://localhost:#{PORT}/many_cookies")
+    assert_equal(4, @agent.cookies.length)
 
-    name_cookie = agent.cookies.find { |k| k.name == "name" }
+    name_cookie = @agent.cookies.find { |k| k.name == "name" }
     assert_not_nil(name_cookie, "Name cookie was nil")
     assert_equal("Aaron", name_cookie.value)
     assert_equal("/", name_cookie.path)
-    assert_equal(true, DateTime.now < name_cookie.expires)
+    assert_equal(true, Time.now < name_cookie.expires)
 
-    expired_cookie = agent.cookies.find { |k| k.name == "expired" }
+    expired_cookie = @agent.cookies.find { |k| k.name == "expired" }
     assert_nil(expired_cookie, "Expired cookie was not nil")
 
-    no_exp_cookie = agent.cookies.find { |k| k.name == "no_expires" }
+    no_exp_cookie = @agent.cookies.find { |k| k.name == "no_expires" }
     assert_not_nil(no_exp_cookie, "No expires cookie is nil")
     assert_equal("nope", no_exp_cookie.value)
     assert_equal("/", no_exp_cookie.path)
     assert_nil(no_exp_cookie.expires)
 
-    path_cookie = agent.cookies.find { |k| k.name == "a_path" }
+    path_cookie = @agent.cookies.find { |k| k.name == "a_path" }
     assert_not_nil(path_cookie, "Path cookie is nil")
     assert_equal("some_path", path_cookie.value)
-    assert_equal(true, DateTime.now < path_cookie.expires)
+    assert_equal(true, Time.now < path_cookie.expires)
 
-    no_path_cookie = agent.cookies.find { |k| k.name == "no_path" }
+    no_path_cookie = @agent.cookies.find { |k| k.name == "no_path" }
     assert_not_nil(no_path_cookie, "No path cookie is nil")
     assert_equal("no_path", no_path_cookie.value)
     assert_equal("/many_cookies", no_path_cookie.path)
-    assert_equal(true, DateTime.now < no_path_cookie.expires)
+    assert_equal(true, Time.now < no_path_cookie.expires)
   end
 
   def test_get_cookie
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
     assert_equal(true,
-      agent.cookie_jar.empty?(
-      URI::parse("http://localhost:#{@port}/one_cookie")))
+      @agent.cookie_jar.empty?(
+      URI::parse("http://localhost:#{PORT}/one_cookie")))
 
-    assert_equal(0, agent.cookies.length)
+    assert_equal(0, @agent.cookies.length)
 
-    page = agent.get("http://localhost:#{@port}/one_cookie")
-    assert_equal(1, agent.cookies.length)
+    page = @agent.get("http://localhost:#{PORT}/one_cookie")
+    assert_equal(1, @agent.cookies.length)
 
-    cookie = agent.cookies.first
+    cookie = @agent.cookies.first
     assert_equal("foo", cookie.name)
     assert_equal("bar", cookie.value)
     assert_equal("/", cookie.path)
     assert_equal("localhost", cookie.domain)
 
     assert_equal(false,
-      agent.cookie_jar.empty?(
-      URI::parse("http://localhost:#{@port}/one_cookie")))
-    page = agent.get("http://localhost:#{@port}/one_cookie")
+      @agent.cookie_jar.empty?(
+      URI::parse("http://localhost:#{PORT}/one_cookie")))
+    page = @agent.get("http://localhost:#{PORT}/one_cookie")
 
-    assert_equal(1, agent.cookies.length)
+    assert_equal(1, @agent.cookies.length)
 
-    cookie = agent.cookies.first
+    cookie = @agent.cookies.first
     assert_equal("foo", cookie.name)
     assert_equal("bar", cookie.value)
     assert_equal("/", cookie.path)

data/test/tc_errors.rb

@@ -8,55 +8,41 @@ require 'test_includes'
 class MechErrorsTest < Test::Unit::TestCase
   include TestMethods
 
-  def test_content_type_error
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/bad_content_type")
-    assert_raise(WWW::Mechanize::ContentTypeError) {
-      page.root
-    }
-    begin
-      page.root
-    rescue WWW::Mechanize::ContentTypeError => ex
-      assert_equal('text/xml', ex.content_type)
-    end
+  def setup
+    @agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
   end
 
   def test_bad_form_method
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/bad_form_test.html")
+    page = @agent.get("http://localhost:#{PORT}/bad_form_test.html")
     assert_raise(RuntimeError) {
-      agent.submit(page.forms.first)
+      @agent.submit(page.forms.first)
     }
   end
 
   def test_too_many_radio
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/form_test.html")
+    page = @agent.get("http://localhost:#{PORT}/form_test.html")
     form = page.forms.name('post_form1').first
     form.radiobuttons.each { |r| r.checked = true }
     assert_raise(RuntimeError) {
-      agent.submit(form)
+      @agent.submit(form)
     }
   end
 
   def test_unknown_agent
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
     assert_raise(RuntimeError) {
-      agent.user_agent_alias = "Aaron's Browser"
+      @agent.user_agent_alias = "Aaron's Browser"
     }
   end
 
   def test_bad_url
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
     assert_raise(RuntimeError) {
-      agent.get('/foo.html')
+      @agent.get('/foo.html')
     }
   end
 
   def test_unsupported_scheme
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
     assert_raise(RuntimeError) {
-      agent.get('ftp://server.com/foo.html')
+      @agent.get('ftp://server.com/foo.html')
     }
   end
 end

data/test/tc_forms.rb

@@ -9,17 +9,19 @@ require 'test_includes'
 class FormsMechTest < Test::Unit::TestCase
   include TestMethods
 
+  def setup
+    @agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+  end
+
   def test_no_form_action
-    mech = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = mech.get('http://localhost:2000/form_no_action.html')
+    page = @agent.get('http://localhost:2000/form_no_action.html')
     page.forms.first.fields.first.value = 'Aaron'
-    page = mech.submit(page.forms.first)
+    page = @agent.submit(page.forms.first)
     assert_match('/form_no_action.html?first=Aaron', page.uri.to_s)
   end
   # Test submitting form with two fields of the same name
   def test_post_multival
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/form_multival.html")
+    page = @agent.get("http://localhost:#{PORT}/form_multival.html")
     form = page.forms.name('post_form').first
 
     assert_not_nil(form)
@@ -28,7 +30,7 @@ class FormsMechTest < Test::Unit::TestCase
     form.fields.name('first')[0].value = 'Aaron'
     form.fields.name('first')[1].value = 'Patterson'
 
-    page = agent.submit(form)
+    page = @agent.submit(form)
 
     assert_not_nil(page)
 
@@ -39,8 +41,7 @@ class FormsMechTest < Test::Unit::TestCase
 
   # Test submitting form with two fields of the same name
   def test_get_multival
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/form_multival.html")
+    page = @agent.get("http://localhost:#{PORT}/form_multival.html")
     form = page.forms.name('get_form').first
 
     assert_not_nil(form)
@@ -49,7 +50,7 @@ class FormsMechTest < Test::Unit::TestCase
     form.fields.name('first')[0].value = 'Aaron'
     form.fields.name('first')[1].value = 'Patterson'
 
-    page = agent.submit(form)
+    page = @agent.submit(form)
 
     assert_not_nil(page)
 
@@ -59,8 +60,7 @@ class FormsMechTest < Test::Unit::TestCase
   end
 
   def test_post
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/form_test.html")
+    page = @agent.get("http://localhost:#{PORT}/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)
@@ -110,7 +110,7 @@ class FormsMechTest < Test::Unit::TestCase
     }.checked = true
     post_form.checkboxes.find { |f| f.name == "likes ham" }.checked = true
     post_form.checkboxes.find { |f| f.name == "green[eggs]" }.checked = true
-    page = agent.submit(post_form, post_form.buttons.first)
+    page = @agent.submit(post_form, post_form.buttons.first)
 
     # Check that the submitted fields exist
     assert_equal(5, page.links.size, "Not enough links")
@@ -137,8 +137,7 @@ class FormsMechTest < Test::Unit::TestCase
   end
 
   def test_select_box
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/form_test.html")
+    page = @agent.get("http://localhost:#{PORT}/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)
@@ -159,7 +158,7 @@ class FormsMechTest < Test::Unit::TestCase
 
     # Now set all the fields
     post_form.fields.name(/country/).value = s.options[1]
-    page = agent.submit(post_form, post_form.buttons.first)
+    page = @agent.submit(post_form, post_form.buttons.first)
 
     # Check that the submitted fields exist
     assert_not_nil(
@@ -169,8 +168,7 @@ class FormsMechTest < Test::Unit::TestCase
   end
 
   def test_get
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/form_test.html")
+    page = @agent.get("http://localhost:#{PORT}/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)
@@ -210,7 +208,7 @@ class FormsMechTest < Test::Unit::TestCase
     }.checked = true
     get_form.checkboxes.find { |f| f.name == "likes ham" }.checked = true
     get_form.checkboxes.find { |f| f.name == "green[eggs]" }.checked = true
-    page = agent.submit(get_form, get_form.buttons.first)
+    page = @agent.submit(get_form, get_form.buttons.first)
 
     # Check that the submitted fields exist
     assert_equal(7, page.links.size, "Not enough links")
@@ -245,8 +243,7 @@ class FormsMechTest < Test::Unit::TestCase
   end
 
   def test_post_with_space_in_action
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/form_test.html")
+    page = @agent.get("http://localhost:#{PORT}/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)
@@ -279,7 +276,7 @@ class FormsMechTest < Test::Unit::TestCase
       f.name == "gender" && f.value == "male" 
     }.checked = true
     post_form.checkboxes.find { |f| f.name == "likes ham" }.checked = true
-    page = agent.submit(post_form, post_form.buttons.first)
+    page = @agent.submit(post_form, post_form.buttons.first)
 
     # Check that the submitted fields exist
     assert_equal(3, page.links.size, "Not enough links")
@@ -298,8 +295,7 @@ class FormsMechTest < Test::Unit::TestCase
   end
 
   def test_get_with_space_in_action
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/form_test.html")
+    page = @agent.get("http://localhost:#{PORT}/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)
@@ -332,7 +328,7 @@ class FormsMechTest < Test::Unit::TestCase
       f.name == "gender" && f.value == "male" 
     }.checked = true
     get_form.checkboxes.find { |f| f.name == "likes ham" }.checked = true
-    page = agent.submit(get_form, get_form.buttons.first)
+    page = @agent.submit(get_form, get_form.buttons.first)
 
     # Check that the submitted fields exist
     assert_equal(3, page.links.size, "Not enough links")
@@ -351,8 +347,7 @@ class FormsMechTest < Test::Unit::TestCase
   end
 
   def test_post_with_param_in_action
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/form_test.html")
+    page = @agent.get("http://localhost:#{PORT}/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)
@@ -385,7 +380,7 @@ class FormsMechTest < Test::Unit::TestCase
       f.name == "gender" && f.value == "male" 
     }.checked = true
     post_form.checkboxes.find { |f| f.name == "likes ham" }.checked = true
-    page = agent.submit(post_form, post_form.buttons.first)
+    page = @agent.submit(post_form, post_form.buttons.first)
 
     # Check that the submitted fields exist
     assert_equal(3, page.links.size, "Not enough links")
@@ -404,8 +399,7 @@ class FormsMechTest < Test::Unit::TestCase
   end
 
   def test_get_with_param_in_action
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/form_test.html")
+    page = @agent.get("http://localhost:#{PORT}/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)
@@ -438,7 +432,7 @@ class FormsMechTest < Test::Unit::TestCase
       f.name == "gender" && f.value == "male" 
     }.checked = true
     get_form.checkboxes.find { |f| f.name == "likes ham" }.checked = true
-    page = agent.submit(get_form, get_form.buttons.first)
+    page = @agent.submit(get_form, get_form.buttons.first)
 
     # Check that the submitted fields exist
     assert_equal(5, page.links.size, "Not enough links")
@@ -465,10 +459,20 @@ class FormsMechTest < Test::Unit::TestCase
   end
 
   def test_field_addition
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/form_test.html")
+    page = @agent.get("http://localhost:#{PORT}/form_test.html")
     get_form = page.forms.find { |f| f.name == "get_form1" }
     get_form.field("first_name").value = "Gregory"
     assert_equal( "Gregory", get_form.field("first_name").value ) 
   end
+
+  def test_fields_as_accessors
+    page = @agent.get("http://localhost:#{PORT}/form_multival.html")
+    form = page.forms.name('post_form').first
+
+    assert_not_nil(form)
+    assert_equal(2, form.fields.name('first').length)
+
+    form.first = 'Aaron'
+    assert_equal('Aaron', form.first)
+  end
 end

data/test/tc_frames.rb

@@ -8,9 +8,12 @@ require 'test_includes'
 class FramesMechTest < Test::Unit::TestCase
   include TestMethods
 
+  def setup
+    @agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+  end
+
   def test_frames
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/frame_test.html")
+    page = @agent.get("http://localhost:#{PORT}/frame_test.html")
     assert_equal(3, page.frames.size)
     assert_equal("frame1", page.frames[0].name)
     assert_equal("frame2", page.frames[1].name)
@@ -21,8 +24,7 @@ class FramesMechTest < Test::Unit::TestCase
   end
 
   def test_iframes
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/iframe_test.html")
+    page = @agent.get("http://localhost:#{PORT}/iframe_test.html")
     assert_equal(1, page.iframes.size)
     assert_equal("frame4", page.iframes.first.name)
     assert_equal("/file_upload.html", page.iframes.first.src)