eric-mechanize 0.9.3.20090623142847

data/test/test_encoded_links.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class TestEncodedLinks < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+    @page = @agent.get("http://localhost/tc_encoded_links.html")
+  end
+
+  def test_click_link
+    link = @page.links.first
+    assert_equal('/form_post?a=b&b=c', link.href)
+    page = @agent.click(link)
+    assert_equal("http://localhost/form_post?a=b&b=c", page.uri.to_s)
+  end
+
+  def test_hpricot_link
+    page = @agent.click(@page.search('a').first)
+    assert_equal("http://localhost/form_post?a=b&b=c", page.uri.to_s)
+  end
+end

data/test/test_errors.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class MechErrorsTest < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_bad_form_method
+    page = @agent.get("http://localhost/bad_form_test.html")
+    assert_raise(RuntimeError) {
+      @agent.submit(page.forms.first)
+    }
+  end
+
+  def test_non_exist
+    begin
+      page = @agent.get("http://localhost/bad_form_test.html")
+    rescue RuntimeError => ex
+      assert_equal("404", ex.inspect)
+    end
+  end
+
+  def test_too_many_radio
+    page = @agent.get("http://localhost/form_test.html")
+    form = page.form_with(:name => 'post_form1')
+    form.radiobuttons.each { |r| r.checked = true }
+    assert_raise(RuntimeError) {
+      @agent.submit(form)
+    }
+  end
+
+  def test_unknown_agent
+    assert_raise(RuntimeError) {
+      @agent.user_agent_alias = "Aaron's Browser"
+    }
+  end
+
+  def test_bad_url
+    assert_raise(RuntimeError) {
+      @agent.get('/foo.html')
+    }
+  end
+
+  def test_unsupported_scheme
+    assert_raise(WWW::Mechanize::UnsupportedSchemeError) {
+      @agent.get('ftp://server.com/foo.html')
+    }
+  end
+end

data/test/test_follow_meta.rb

@@ -0,0 +1,108 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class FollowMetaTest < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_dont_follow_meta_by_default
+    page = @agent.get('http://localhost/tc_follow_meta.html')
+    assert_equal('http://localhost/tc_follow_meta.html', page.uri.to_s)
+    assert_equal(1, page.meta.length)
+  end
+
+  def test_meta_refresh_does_not_send_referer
+    @agent.follow_meta_refresh = true
+    requests = []
+    @agent.pre_connect_hooks << lambda { |params|
+      requests << params[:request]
+    }
+
+    page = @agent.get('http://localhost/tc_follow_meta.html')
+    assert_nil requests[1]['referer']
+  end
+
+  def test_follow_meta_if_set
+    @agent.follow_meta_refresh = true
+
+    page = @agent.get('http://localhost/tc_follow_meta.html')
+
+    assert_equal(2, @agent.history.length)
+    assert_equal('http://localhost/tc_follow_meta.html',
+                 @agent.history[0].uri.to_s)
+    assert_equal('http://localhost/index.html', page.uri.to_s)
+    assert_equal('http://localhost/index.html', @agent.history.last.uri.to_s)
+  end
+  
+  def test_follow_meta_with_empty_url
+    @agent.follow_meta_refresh = true
+  
+    page = @agent.get('http://localhost/refresh_with_empty_url')
+  
+    assert_equal(3, @agent.history.length)
+    assert_equal('http://localhost/refresh_with_empty_url',
+                 @agent.history[0].uri.to_s)
+    assert_equal('http://localhost/refresh_with_empty_url',
+                 @agent.history[1].uri.to_s)
+    assert_equal('http://localhost/index.html', page.uri.to_s)
+    assert_equal('http://localhost/index.html', @agent.history.last.uri.to_s)
+  end
+  
+  def test_follow_meta_without_url
+    @agent.follow_meta_refresh = true
+  
+    page = @agent.get('http://localhost/refresh_without_url')
+  
+    assert_equal(3, @agent.history.length)
+    assert_equal('http://localhost/refresh_without_url',
+                 @agent.history[0].uri.to_s)
+    assert_equal('http://localhost/refresh_without_url',
+                 @agent.history[1].uri.to_s)
+    assert_equal('http://localhost/index.html', page.uri.to_s)
+    assert_equal('http://localhost/index.html', @agent.history.last.uri.to_s)
+  end
+
+  def test_always_follow_302
+    @agent.follow_meta_refresh = false
+    page = @agent.get('http://localhost/response_code?code=302&ct=test/xml')
+    assert_equal('http://localhost/index.html', page.uri.to_s)
+    assert_equal(2, @agent.history.length)
+  end
+
+  def test_infinite_refresh_throws_exception
+    @agent.follow_meta_refresh = true
+    assert_raises(WWW::Mechanize::RedirectLimitReachedError) {
+      begin
+        @agent.get('http://localhost/infinite_refresh')
+      rescue WWW::Mechanize::RedirectLimitReachedError => ex
+        raise ex
+      end
+    }
+  end
+  
+  def test_dont_honor_http_refresh_by_default
+    page = @agent.get('http://localhost/http_refresh?refresh_time=0')
+    assert_equal('http://localhost/http_refresh?refresh_time=0', page.uri.to_s)
+  end
+  
+  def test_honor_http_refresh_if_set
+    @agent.follow_meta_refresh = true
+    page = @agent.get('http://localhost/http_refresh?refresh_time=0')
+    assert_equal('http://localhost/index.html', page.uri.to_s)
+    assert_equal(2, @agent.history.length)
+  end
+
+  def test_honor_http_refresh_delay_if_set
+    @agent.follow_meta_refresh = true
+    class << @agent
+      attr_accessor :slept
+      def sleep *args
+        @slept = args
+      end
+    end
+
+    page = @agent.get('http://localhost/http_refresh?refresh_time=1')
+    assert_equal [1], @agent.slept
+  end
+
+end

data/test/test_form_action.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class TestFormAction < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+    @page  = @agent.get("http://localhost/tc_form_action.html")
+  end
+
+  def test_post_with_bad_encoding_does_not_raise_exception
+    @page  = @agent.get("http://localhost/test_bad_encoding.html")
+    form = @page.form(:name => 'post_form1') { |f|
+      f.first_name = "Aaron"
+    }
+    form.submit
+  end
+
+  def test_post_encoded_action
+    form = @page.form(:name => 'post_form1') { |f|
+      f.first_name = "Aaron"
+    }
+    assert_equal('/form_post?a=b&b=c', form.action)
+    page = form.submit
+    assert_equal("http://localhost/form_post?a=b&b=c", page.uri.to_s)
+  end
+
+  def test_get_encoded_action
+    form = @page.form('post_form2') { |f|
+      f.first_name = "Aaron"
+    }
+    assert_equal('/form_post?a=b&b=c', form.action)
+    page = form.submit
+    assert_equal("http://localhost/form_post?first_name=Aaron", page.uri.to_s)
+  end
+
+  def test_post_nonencoded_action
+    form = @page.form('post_form3') { |f|
+      f.first_name = "Aaron"
+    }
+    assert_equal('/form_post?a=b&b=c', form.action)
+    page = form.submit
+    assert_equal("http://localhost/form_post?a=b&b=c", page.uri.to_s)
+  end
+
+  def test_post_pound_sign
+    form = @page.form('post_form4') { |f|
+      f.first_name = "Aaron"
+    }
+    assert_equal('/form_post#1', form.action)
+    page = form.submit
+    assert_equal("http://localhost/form_post#1", page.uri.to_s)
+  end
+end

data/test/test_form_as_hash.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class TestFormHash < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+    @page  = @agent.get('http://localhost/form_multival.html')
+  end
+
+  def test_form_hash
+    form = @page.form_with(:name => 'post_form')
+
+    assert_not_nil(form)
+    field_length = form.fields.length
+    assert_nil(form['intarweb'])
+    form['intarweb'] = 'Aaron'
+
+    assert_not_nil(form['intarweb'])
+    assert_equal(field_length + 1, form.fields.length)
+  end
+
+  def test_add_field_via_hash
+    form = @page.form_with(:name => 'post_form')
+
+    assert_not_nil(form)
+    field_length = form.fields.length
+    assert_nil(form['intarweb'])
+    form['intarweb'] = 'Aaron'
+
+    assert_not_nil(form['intarweb'])
+    assert_equal(field_length + 1, form.fields.length)
+  end
+
+  def test_fields_as_hash
+    form = @page.form_with(:name => 'post_form')
+
+    assert_not_nil(form)
+    assert_equal(2, form.fields_with(:name => 'first').length)
+
+    form['first'] = 'Aaron'
+    assert_equal('Aaron', form['first'])
+    assert_equal('Aaron', form.field_with(:name => 'first').value)
+  end
+
+  def test_keys
+    @page = @agent.get('http://localhost/empty_form.html')
+    form = @page.forms.first
+
+    assert_not_nil(form)
+    assert_equal(false, form.has_field?('name'))
+    assert_equal(false, form.has_value?('Aaron'))
+    assert_equal(0, form.keys.length)
+    assert_equal(0, form.values.length)
+    form['name'] = 'Aaron'
+    assert_equal(true, form.has_field?('name'))
+    assert_equal(true, form.has_value?('Aaron'))
+    assert_equal(1, form.keys.length)
+    assert_equal(['name'], form.keys)
+    assert_equal(1, form.values.length)
+    assert_equal(['Aaron'], form.values)
+  end
+end

data/test/test_form_button.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class TestFormButtons < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_submit_input_tag
+    assert_form_contains_button('<input type="submit" value="submit" />')
+  end
+
+  def test_button_input_tag
+    assert_form_contains_button('<input type="button" value="submit" />')
+  end
+
+  def test_submit_button_tag
+    assert_form_contains_button('<button type="submit" value="submit"/>')
+  end
+
+  def test_button_button_tag
+    assert_form_contains_button('<button type="button" value="submit"/>')
+  end
+
+  def assert_form_contains_button(button)
+    page = WWW::Mechanize::Page.new(nil, html_response, html(button), 200, @agent)
+    assert_equal(1, page.forms.length)
+    assert_equal(1, page.forms.first.buttons.length)
+  end
+
+  def html(input)
+    "<html><body><form>#{input}</form></body></html>"
+  end
+
+  def html_response
+    { 'content-type' => 'text/html' }
+  end
+end
+

data/test/test_form_no_inputname.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class FormNoInputNameTest < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+    @page = @agent.get('http://localhost/form_no_input_name.html')
+  end
+
+  def test_no_input_name
+    form = @page.forms.first
+    assert_equal(0, form.fields.length)
+    assert_equal(0, form.radiobuttons.length)
+    assert_equal(0, form.checkboxes.length)
+  end
+end

data/test/test_forms.rb

@@ -0,0 +1,564 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class FormsMechTest < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_no_form_action
+    page = @agent.get('http://localhost:2000/form_no_action.html')
+    page.forms.first.fields.first.value = 'Aaron'
+    page = @agent.submit(page.forms.first)
+    assert_match('/form_no_action.html?first=Aaron', page.uri.to_s)
+  end
+
+  def test_submit_takes_arbirary_headers
+    page = @agent.get('http://localhost:2000/form_no_action.html')
+    assert form = page.forms.first
+    form.action = '/http_headers'
+    page = @agent.submit(form, nil, { 'foo' => 'bar' })
+    headers = Hash[*(
+      page.body.split("\n").map { |x| x.split('|') }.flatten
+    )]
+    assert_equal 'bar', headers['foo']
+  end
+
+  # Test submitting form with two fields of the same name
+  def test_post_multival
+    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'
+    form.fields_with(:name => 'first')[1].value = 'Patterson'
+
+    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'))
+  end
+
+  # Test calling submit on the form object
+  def test_submit_on_form
+    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'
+    form.fields_with(:name => 'first')[1].value = 'Patterson'
+
+    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'))
+  end
+
+  # Test submitting form with two fields of the same name
+  def test_get_multival
+    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'
+    form.fields_with(:name => 'first')[1].value = 'Patterson'
+
+    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'))
+  end
+
+  def test_post_with_non_strings
+    page = @agent.get("http://localhost/form_test.html")
+    page.form('post_form1') do |form|
+      form.first_name = 10
+    end.submit
+  end
+
+  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)
+
+    assert_equal(3, post_form.fields.size)
+
+    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")
+
+    # Find the select list
+    s = post_form.fields.find { |f| f.name == "country" }
+    assert_equal(2, s.options.length)
+    assert_equal("USA", s.value)
+    assert_equal("USA", s.options.first.value)
+    assert_equal("USA", s.options.first.text)
+    assert_equal("CANADA", s.options[1].value)
+    assert_equal("CANADA", s.options[1].text)
+
+    # Now set all the fields
+    post_form.fields.find { |f| f.name == "first_name" }.value = "Aaron"
+    post_form.radiobuttons.find { |f| 
+      f.name == "gender" && f.value == "male" 
+    }.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)
+
+    # 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"
+    )
+  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_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)
+    
+    page = @agent.submit(post_form, post_form.buttons.first)
+    
+    assert_not_nil(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_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)
+    assert_equal("USA", s.options.first.text)
+    assert_equal("CANADA", s.options[1].value)
+    assert_equal("CANADA", s.options[1].text)
+
+    # Now set all the fields
+    post_form.field_with(:name => /country/).value = s.options[1]
+    assert_equal('CANADA', post_form.country)
+    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"
+    )
+  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")
+
+    # Set up the image button
+    img = get_form.buttons.find { |f| f.name == "button" }
+    img.x = "9"
+    img.y = "10"
+    # Now set all the fields
+    get_form.fields.find { |f| f.name == "first_name" }.value = "Aaron"
+    get_form.radiobuttons.find { |f| 
+      f.name == "gender" && f.value == "male" 
+    }.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)
+
+    # Check that the submitted fields exist
+    assert_equal(7, 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_not_nil(
+      page.links.find { |l| l.text == "button:button" },
+      "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")
+
+    # Now set all the fields
+    post_form.fields.find { |f| f.name == "first_name" }.value = "Aaron"
+    post_form.radiobuttons.find { |f| 
+      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)
+
+    # 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"
+    )
+  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")
+
+    # Now set all the fields
+    get_form.fields.find { |f| f.name == "first_name" }.value = "Aaron"
+    get_form.radiobuttons.find { |f| 
+      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)
+
+    # 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"
+    )
+  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)
+    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.checkbox_with(: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")
+
+    # Now set all the fields
+    post_form.field_with(:name => 'first_name').value = "Aaron"
+    post_form.radiobuttons.find { |f| 
+      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)
+
+    # 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"
+    )
+  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")
+
+    # Now set all the fields
+    get_form.fields.find { |f| f.name == "first_name" }.value = "Aaron"
+    get_form.radiobuttons.find { |f| 
+      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)
+    # 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"
+    )
+  end
+
+  def test_field_addition
+    page = @agent.get("http://localhost/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/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'
+    assert_equal('Aaron', form.first)
+  end
+
+  def test_add_field
+    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_equal(number_of_fields + 1, form.fields.length)
+  end
+  
+  def test_delete_field
+    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
+
+    form.delete_field!('first')
+    assert_nil(form['first'])
+    assert_equal(number_of_fields - 2, form.fields.length)    
+  end
+
+  def test_has_field
+    page = @agent.get("http://localhost/form_multival.html")
+    form = page.form_with(:name => 'post_form')
+
+    assert_not_nil(form)
+    assert_equal(false, form.has_field?('intarweb'))
+    f = form.add_field!('intarweb')
+    assert_not_nil(f)
+    assert_equal(true, form.has_field?('intarweb'))
+  end
+
+  def test_field_error
+    @page = @agent.get('http://localhost/empty_form.html')
+    form = @page.forms.first
+    assert_raise(NoMethodError) {
+      form.foo = 'asdfasdf'
+    }
+
+    assert_raise(NoMethodError) {
+      form.foo
+    }
+  end
+end