husc 0.1.0

data/vendor/bundle/gems/mechanize-2.7.6/test/test_mechanize_directory_saver.rb

@@ -0,0 +1,59 @@
+require 'mechanize/test_case'
+
+class TestMechanizeDirectorySaver < Mechanize::TestCase
+
+  def setup
+    super
+
+    @uri = URI 'http://example/relative/tc_relative_links.html'
+    @io = StringIO.new 'hello world'
+  end
+
+  def test_self_save_to
+    in_tmpdir do
+      saver = Mechanize::DirectorySaver.save_to 'dir'
+
+      saver.new @uri, nil, @io, 200
+
+      assert File.exist? 'dir/tc_relative_links.html'
+      refute File.exist? 'dir/relative'
+    end
+  end
+
+  def test_self_save_to_cd
+    in_tmpdir do
+      saver = Mechanize::DirectorySaver.save_to 'dir'
+
+      FileUtils.mkdir 'other'
+
+      Dir.chdir 'other' do
+        saver.new @uri, nil, @io, 200
+      end
+
+      assert File.exist? 'dir/tc_relative_links.html'
+      refute File.exist? 'dir/relative'
+    end
+  end
+
+  def test_with_decode_filename
+    in_tmpdir do
+      saver = Mechanize::DirectorySaver.save_to 'dir', :decode_filename => true
+      uri = URI 'http://example.com/foo+bar.html'
+      saver.new uri, nil, @io, 200
+
+      assert File.exist? 'dir/foo bar.html'
+    end
+  end
+
+  def test_initialize_no_save_dir
+    in_tmpdir do
+      e = assert_raises Mechanize::Error do
+        Mechanize::DirectorySaver.new @uri, nil, @io, 200
+      end
+
+      assert_match %r%no save directory specified%, e.message
+    end
+  end
+
+end
+

data/vendor/bundle/gems/mechanize-2.7.6/test/test_mechanize_download.rb

@@ -0,0 +1,89 @@
+require 'mechanize/test_case'
+
+class TestMechanizeDownload < Mechanize::TestCase
+
+  def setup
+    super
+
+    @parser = Mechanize::Download
+  end
+
+  def test_body
+    uri = URI.parse 'http://example/foo.html'
+    body_io = StringIO.new '0123456789'
+
+    download = @parser.new uri, nil, body_io
+
+    assert_equal '0123456789', download.body
+    assert_equal 0, download.body_io.pos
+  end
+
+  def test_save_string_io
+    uri = URI.parse 'http://example/foo.html'
+    body_io = StringIO.new '0123456789'
+
+    download = @parser.new uri, nil, body_io
+
+    in_tmpdir do
+      filename = download.save
+
+      assert File.exist? 'foo.html'
+      assert_equal "foo.html", filename
+    end
+  end
+
+  def test_save_bang
+    uri = URI.parse 'http://example/foo.html'
+    body_io = StringIO.new '0123456789'
+
+    download = @parser.new uri, nil, body_io
+
+    in_tmpdir do
+      filename = download.save!
+
+      assert File.exist? 'foo.html'
+      assert_equal "foo.html", filename
+    end
+  end
+
+  def test_save_tempfile
+    uri = URI.parse 'http://example/foo.html'
+    Tempfile.open @NAME do |body_io|
+      body_io.unlink
+      body_io.write '0123456789'
+
+      body_io.flush
+      body_io.rewind
+
+      download = @parser.new uri, nil, body_io
+
+      in_tmpdir do
+        filename = download.save
+
+        assert File.exist? 'foo.html'
+        assert_equal "foo.html", filename
+
+        filename = download.save
+
+        assert File.exist? 'foo.html.1'
+        assert_equal "foo.html.1", filename
+
+        filename = download.save
+
+        assert File.exist? 'foo.html.2'
+        assert_equal "foo.html.2", filename
+      end
+    end
+  end
+
+  def test_filename
+    uri = URI.parse 'http://example/foo.html'
+    body_io = StringIO.new '0123456789'
+
+    download = @parser.new uri, nil, body_io
+
+    assert_equal "foo.html", download.filename
+  end
+
+end
+

data/vendor/bundle/gems/mechanize-2.7.6/test/test_mechanize_element_not_found_error.rb

@@ -0,0 +1,15 @@
+require 'mechanize/test_case'
+
+class TestMechanizeRedirectLimitReachedError < Mechanize::TestCase
+
+  def test_to_s
+    page = fake_page
+
+    error = Mechanize::ElementNotFoundError.new(page, :element, :conditions)
+
+    assert_match(/element/, error.to_s)
+    assert_match(/conditions/, error.to_s)
+  end
+
+end
+

data/vendor/bundle/gems/mechanize-2.7.6/test/test_mechanize_file.rb

@@ -0,0 +1,107 @@
+require 'mechanize/test_case'
+
+class TestMechanizeFile < Mechanize::TestCase
+
+  def setup
+    super
+
+    @parser = Mechanize::File
+  end
+
+  def test_save
+    uri = URI 'http://example/name.html'
+    page = Mechanize::File.new uri, nil, '0123456789'
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do
+        filename = page.save 'test.html'
+
+        assert File.exist? 'test.html'
+        assert_equal '0123456789', File.read('test.html')
+        assert_equal "test.html", filename
+
+        filename = page.save 'test.html'
+
+        assert File.exist? 'test.html.1'
+        assert_equal '0123456789', File.read('test.html.1')
+        assert_equal "test.html.1", filename
+
+        filename = page.save 'test.html'
+
+        assert File.exist? 'test.html.2'
+        assert_equal '0123456789', File.read('test.html.2')
+        assert_equal "test.html.2", filename
+      end
+    end
+  end
+
+  def test_save_default
+    uri = URI 'http://example/test.html'
+    page = Mechanize::File.new uri, nil, ''
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do
+        filename = page.save
+
+        assert File.exist? 'test.html'
+        assert_equal "test.html", filename
+
+        filename = page.save
+
+        assert File.exist? 'test.html.1'
+        assert_equal "test.html.1", filename
+
+        filename = page.save
+
+        assert File.exist? 'test.html.2'
+        assert_equal "test.html.2", filename
+      end
+    end
+  end
+
+  def test_save_default_dots
+    uri = URI 'http://localhost/../test.html'
+    page = Mechanize::File.new uri, nil, ''
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do
+        filename = page.save
+        assert File.exist? 'test.html'
+        assert_equal "test.html", filename
+
+        filename = page.save
+        assert File.exist? 'test.html.1'
+        assert_equal "test.html.1", filename
+      end
+    end
+  end
+
+  def test_filename
+    uri = URI 'http://localhost/test.html'
+    page = Mechanize::File.new uri, nil, ''
+
+    assert_equal "test.html", page.filename
+  end
+
+  def test_save_overwrite
+    uri = URI 'http://example/test.html'
+    page = Mechanize::File.new uri, nil, ''
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do
+        filename = page.save 'test.html'
+
+        assert File.exist? 'test.html'
+        assert_equal "test.html", filename
+
+        filename = page.save! 'test.html'
+
+        assert File.exist? 'test.html'
+        refute File.exist? 'test.html.1'
+        assert_equal "test.html", filename
+      end
+    end
+  end
+
+end
+

data/vendor/bundle/gems/mechanize-2.7.6/test/test_mechanize_file_connection.rb

@@ -0,0 +1,21 @@
+require 'mechanize/test_case'
+
+class TestMechanizeFileConnection < Mechanize::TestCase
+
+  def test_request
+    uri = URI.parse "file://#{File.expand_path __FILE__}"
+    conn = Mechanize::FileConnection.new
+
+    body = ''
+
+    conn.request uri, nil do |response|
+      response.read_body do |part|
+        body << part
+      end
+    end
+
+    assert_equal File.read(__FILE__), body
+  end
+
+end
+

data/vendor/bundle/gems/mechanize-2.7.6/test/test_mechanize_file_request.rb

@@ -0,0 +1,25 @@
+require 'mechanize/test_case'
+
+class TestMechanizeFileRequest < Mechanize::TestCase
+
+  def setup
+    @uri = URI.parse 'file:///nonexistent'
+
+    @r = Mechanize::FileRequest.new @uri
+  end
+
+  def test_initialize
+    assert_equal @uri, @r.uri
+    assert_equal '/nonexistent', @r.path
+
+    assert_respond_to @r, :[]=
+    assert_respond_to @r, :add_field
+    assert_respond_to @r, :each_header
+  end
+
+  def test_response_body_permitted_eh
+    assert @r.response_body_permitted?
+  end
+
+end
+

data/vendor/bundle/gems/mechanize-2.7.6/test/test_mechanize_file_response.rb

@@ -0,0 +1,23 @@
+require 'mechanize/test_case'
+
+class TestMechanizeFileResponse < Mechanize::TestCase
+
+  def test_content_type
+    Tempfile.open %w[pi .nothtml] do |tempfile|
+      res = Mechanize::FileResponse.new tempfile.path
+      assert_nil res['content-type']
+    end
+
+    Tempfile.open %w[pi .xhtml] do |tempfile|
+      res = Mechanize::FileResponse.new tempfile.path
+      assert_equal 'text/html', res['content-type']
+    end
+
+    Tempfile.open %w[pi .html] do |tempfile|
+      res = Mechanize::FileResponse.new tempfile.path
+      assert_equal 'text/html', res['Content-Type']
+    end
+  end
+
+end
+

data/vendor/bundle/gems/mechanize-2.7.6/test/test_mechanize_file_saver.rb

@@ -0,0 +1,21 @@
+require 'mechanize/test_case'
+
+class TestMechanizeFileSaver < Mechanize::TestCase
+
+  def setup
+    super
+
+    @uri = URI 'http://example'
+    @io = StringIO.new 'hello world'
+  end
+
+  def test_initialize
+    in_tmpdir do
+      Mechanize::FileSaver.new @uri, nil, @io, 200
+
+      assert File.exist? 'example/index.html'
+    end
+  end
+
+end
+

data/vendor/bundle/gems/mechanize-2.7.6/test/test_mechanize_form.rb

@@ -0,0 +1,1012 @@
+require 'mechanize/test_case'
+
+class TestMechanizeForm < Mechanize::TestCase
+
+  def setup
+    super
+
+    @uri = URI 'http://example'
+    @page = page @uri
+
+    @form = Mechanize::Form.new node('form', 'name' => @NAME), @mech, @page
+  end
+
+  def test_action
+    form = Mechanize::Form.new node('form', 'action' => '?a=b&amp;b=c')
+
+    assert_equal '?a=b&b=c', form.action
+  end
+
+  def test_add_button_to_query
+    button = Mechanize::Form::Button.new node('input', 'type' => 'submit')
+
+    e = assert_raises ArgumentError do
+      @form.add_button_to_query button
+    end
+
+    assert_equal "#{button.inspect} does not belong to the same page " \
+                 "as the form \"#{@NAME}\" in #{@uri}",
+                 e.message
+  end
+
+  def test_aset
+    assert_empty @form.keys
+
+    @form['intarweb'] = 'Aaron'
+
+    assert_equal 'Aaron', @form['intarweb']
+  end
+
+  def test_aset_exists
+    page = html_page <<-BODY
+<title>Page Title</title>
+<form name="post_form">
+  <input name="first" type="text" id="name_first">
+  <input name="first" type="text">
+  <input type="submit" value="Submit">
+</form>
+    BODY
+
+    form = page.form_with(:name => 'post_form')
+
+    assert_equal %w[first first], form.keys
+
+    form['first'] = 'Aaron'
+
+    assert_equal 'Aaron', form['first']
+    assert_equal ['Aaron', ''], form.values
+  end
+
+  def test_build_query_blank_form
+    page = @mech.get('http://localhost/tc_blank_form.html')
+    form = page.forms.first
+    query = form.build_query
+    assert(query.length > 0)
+    assert query.all? { |x| x[1] == '' }
+  end
+
+  def test_build_query_radio_button_duplicate
+    html = Nokogiri::HTML <<-HTML
+<form>
+  <input type=radio name=name value=a checked=true>
+  <input type=radio name=name value=a checked=true>
+</form>
+    HTML
+
+    form = Mechanize::Form.new html.at('form'), @mech, @page
+
+    query = form.build_query
+
+    assert_equal [%w[name a]], query
+  end
+
+  def test_build_query_radio_button_multiple_checked
+    html = Nokogiri::HTML <<-HTML
+<form>
+  <input type=radio name=name value=a checked=true>
+  <input type=radio name=name value=b checked=true>
+</form>
+    HTML
+
+    form = Mechanize::Form.new html.at('form'), @mech, @page
+
+    e = assert_raises Mechanize::Error do
+      form.build_query
+    end
+
+    assert_equal 'radiobuttons "a, b" are checked in the "name" group, ' \
+                 'only one is allowed',
+                 e.message
+  end
+
+  def test_method_missing_get
+    page = html_page <<-BODY
+<form>
+  <input name="not_a_method" value="some value">
+</form>
+    BODY
+
+    form = page.forms.first
+
+    assert_equal 'some value', form.not_a_method
+  end
+
+  def test_method_missing_set
+    page = html_page <<-BODY
+<form>
+  <input name="not_a_method">
+</form>
+    BODY
+
+    form = page.forms.first
+
+    form.not_a_method = 'some value'
+
+    assert_equal [%w[not_a_method some\ value]], form.build_query
+  end
+
+  def test_parse_buttons
+    page = html_page <<-BODY
+<form>
+  <input type="submit" value="submit">
+  <input type="button" value="submit">
+  <button type="submit" value="submit">
+  <button type="button" value="submit">
+  <input type="image" name="submit" src="/button.jpeg">
+  <input type="image" src="/button.jpeg">
+</form>
+    BODY
+
+    form = page.forms.first
+    buttons = form.buttons.sort
+
+    assert buttons.all? { |b| Mechanize::Form::Button === b }
+
+    assert_equal 'submit', buttons.shift.type
+    assert_equal 'button', buttons.shift.type
+    assert_equal 'submit', buttons.shift.type
+    assert_equal 'button', buttons.shift.type
+    assert_equal 'image',  buttons.shift.type
+    assert_equal 'image',  buttons.shift.type
+
+    assert_empty buttons
+  end
+
+  def test_parse_select
+    page = html_page <<-BODY
+<form>
+  <select name="multi" multiple></select>
+  <select name="single"></select>
+</form>
+    BODY
+
+    form = page.forms.first
+    selects = form.fields.sort
+
+    multi = selects.shift
+    assert_kind_of Mechanize::Form::MultiSelectList, multi
+
+    single = selects.shift
+    assert_kind_of Mechanize::Form::SelectList, single
+
+    assert_empty selects
+  end
+
+  def test_checkboxes_no_input_name
+    page = @mech.get('http://localhost/form_no_input_name.html')
+    form = page.forms.first
+
+    assert_equal(0, form.checkboxes.length)
+  end
+
+  def test_field_with
+    page = @mech.get("http://localhost/google.html")
+    search = page.forms.find { |f| f.name == "f" }
+
+    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
+    page = @mech.get('http://localhost/form_no_input_name.html')
+    form = page.forms.first
+
+    assert_equal(0, form.fields.length)
+  end
+
+  def test_file_uploads_no_value
+    page = @mech.get("http://localhost/file_upload.html")
+    form = page.form('value_test')
+    assert_nil(form.file_uploads.first.value)
+    assert_nil(form.file_uploads.first.file_name)
+  end
+
+  def test_forms_no_input_name
+    page = @mech.get('http://localhost/form_no_input_name.html')
+    form = page.forms.first
+
+    assert_equal(0, form.radiobuttons.length)
+  end
+
+  def test_has_field_eh
+    refute @form.has_field? 'name'
+
+    @form['name'] = 'Aaron'
+
+    assert_equal true, @form.has_field?('name')
+  end
+
+  def test_has_value_eh
+    refute @form.has_value? 'Aaron'
+
+    @form['name'] = 'Aaron'
+
+    assert_equal true, @form.has_value?('Aaron')
+  end
+
+  def test_keys
+    assert_empty @form.keys
+
+    @form['name'] = 'Aaron'
+
+    assert_equal %w[name], @form.keys
+  end
+
+  def test_parse_textarea
+    form = Nokogiri::HTML <<-FORM
+<form>
+<textarea name="t">hi</textarea>
+</form>
+    FORM
+
+    form = Mechanize::Form.new form, @mech
+    textarea = form.fields.first
+
+    assert_kind_of Mechanize::Form::Textarea, textarea
+    assert_equal 'hi', textarea.value
+  end
+
+  def test_post_with_rails_3_encoding_hack
+    page = @mech.get("http://localhost/rails_3_encoding_hack_form_test.html")
+    form = page.forms.first
+    form.submit
+  end
+
+  def test_post_with_blank_encoding
+    page = @mech.get("http://localhost/form_test.html")
+    form = page.form('post_form1')
+    form.page.encoding = nil
+    form.submit
+  end
+
+  def test_set_fields_duplicate
+    page = html_page '<form><input name="a" value="b"><input name="a"></form>'
+    form = page.forms.first
+
+    form.set_fields :a => 'c'
+
+    assert_equal 'c', form.fields.first.value
+    assert_equal '', form.fields.last.value
+  end
+
+  def test_set_fields_none
+    page = html_page '<form><input name="a" value="b"></form>'
+    form = page.forms.first
+
+    form.set_fields
+
+    assert_equal 'b', form.fields.first.value
+  end
+
+  def test_set_fields_many
+    page = html_page '<form><input name="a" value="b"><input name="b"></form>'
+    form = page.forms.first
+
+    form.set_fields :a => 'c', :b => 'd'
+
+    assert_equal 'c', form.fields.first.value
+    assert_equal 'd', form.fields.last.value
+  end
+
+  def test_set_fields_one
+    page = html_page '<form><input name="a" value="b"></form>'
+    form = page.forms.first
+
+    form.set_fields :a => 'c'
+
+    assert_equal 'c', form.fields.first.value
+  end
+
+  def test_set_fields_position
+    page = html_page '<form><input name="a" value="b"><input name="a"></form>'
+    form = page.forms.first
+
+    form.set_fields :a => { 0 => 'c', 1 => 'd' }
+
+    assert_equal 'c', form.fields.first.value
+    assert_equal 'd', form.fields.last.value
+  end
+
+  def test_set_fields_position_crappily
+    page = html_page '<form><input name="a" value="b"><input name="a"></form>'
+    form = page.forms.first
+
+    form.set_fields :a => ['c', 1]
+
+    assert_equal 'b', form.fields.first.value
+    assert_equal 'c', form.fields.last.value
+  end
+
+  def test_values
+    assert_empty @form.values
+
+    @form['name'] = 'Aaron'
+
+    assert_equal %w[Aaron], @form.values
+  end
+
+  def test_no_form_action
+    page = @mech.get('http://localhost:2000/form_no_action.html')
+    page.forms.first.fields.first.value = 'Aaron'
+    page = @mech.submit(page.forms.first)
+    assert_match('/form_no_action.html?first=Aaron', page.uri.to_s)
+  end
+
+  def test_submit_first_field_wins
+    page = @mech.get('http://localhost/tc_field_precedence.html')
+    form = page.forms.first
+
+    assert !form.checkboxes.empty?
+    assert_equal "1", form.checkboxes.first.value
+
+    submitted = form.submit
+
+    assert_equal 'ticky=1&ticky=0', submitted.parser.at('#query').text
+  end
+
+  def test_submit_takes_arbirary_headers
+    page = @mech.get('http://localhost:2000/form_no_action.html')
+    assert form = page.forms.first
+    form.action = '/http_headers'
+    page = @mech.submit(form, nil, { 'foo' => 'bar' })
+
+    headers = page.body.split("\n").map { |x| x.split('|', 2) }.flatten
+    headers = Hash[*headers]
+
+    assert_equal 'bar', headers['foo']
+  end
+
+  def test_submit_select_default_all
+    page = html_page <<-BODY
+<form name="form1" method="post" action="/form_post">
+  <select name="list">
+    <option value="1" selected>Option 1</option>
+    <option value="2" selected>Option 2</option>
+    <option value="3" selected>Option 3</option>
+    <option value="4" selected>Option 4</option>
+    <option value="5" selected>Option 5</option>
+    <option value="6" selected>Option 6</option>
+  </select>
+  <br />
+  <input type="submit" value="Submit" />
+</form>
+    BODY
+
+    form = page.forms.first
+    assert_equal "6", form.list
+
+    page = @mech.submit form
+    assert_equal 1, page.links.length
+    assert_equal 1, page.links_with(:text => 'list:6').length
+  end
+
+  def test_submit_select_default_none
+    page = html_page <<-BODY
+<form name="form1" method="post" action="/form_post">
+  <select name="list">
+    <option value="1">Option 1</option>
+    <option value="2">Option 2</option>
+    <option>Option No Value</option>
+    <option value="3">Option 3</option>
+    <option value="4">Option 4</option>
+    <option value="5">Option 5</option>
+    <option value="6">Option 6</option>
+  </select>
+  <br />
+  <input type="submit" value="Submit" />
+</form>
+    BODY
+
+    form = page.forms.first
+
+    assert_equal "1", form.list
+    page = @mech.submit form
+
+    assert_equal 1, page.links.length
+    assert_equal 1, page.links_with(:text => 'list:1').length
+  end
+
+  def test_form_select_default_noopts
+    page = html_page <<-BODY
+<form name="form1" method="post" action="/form_post">
+  <select name="list">
+  </select>
+  <br />
+  <input type="submit" value="Submit" />
+</form>
+    BODY
+    form = page.forms.first
+
+    assert form.field 'list'
+    assert_nil form.list
+
+    page = @mech.submit form
+
+    assert_empty page.links
+  end
+
+  # Test submitting form with two fields of the same name
+  def test_post_multival
+    page = @mech.get("http://localhost/form_multival.html")
+    form = page.form_with(:name => 'post_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 = @mech.submit(form)
+
+    assert_equal(2, page.links.length)
+    assert(page.link_with(:text => 'first:Aaron'))
+    assert(page.link_with(:text => 'first:Patterson'))
+  end
+
+  # Test calling submit on the form object
+  def test_submit_on_form
+    page = @mech.get("http://localhost/form_multival.html")
+    form = page.form_with(:name => 'post_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_equal(2, page.links.length)
+    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
+  def test_get_multival
+    page = @mech.get("http://localhost/form_multival.html")
+    form = page.form_with(:name => 'get_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 = @mech.submit(form)
+
+    assert_equal(2, page.links.length)
+    assert(page.link_with(:text => 'first:Aaron'))
+    assert(page.link_with(:text => 'first:Patterson'))
+  end
+
+  def test_post_with_non_strings
+    page = @mech.get("http://localhost/form_test.html")
+    page.form('post_form1') do |form|
+      form.first_name = 10
+    end.submit
+  end
+
+  def test_post_with_bang
+    page = @mech.get("http://localhost/form_test.html")
+    page.form_with!(:name => 'post_form1') do |form|
+      form.first_name = 10
+    end.submit
+  end
+
+  def test_post
+    page = @mech.get("http://localhost/form_test.html")
+    post_form = page.forms.find { |f| f.name == "post_form1" }
+
+    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(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" }
+    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 = @mech.submit(post_form, post_form.buttons.first)
+
+    # Check that the submitted fields exist
+    assert_equal(5, page.links.size, "Not enough links")
+    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 = @mech.get("http://localhost/form_test.html")
+    post_form = page.forms.find { |f| f.name == "post_form4_multipart" }
+    assert(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 = @mech.submit(post_form, post_form.buttons.first)
+
+    assert page
+  end
+
+  def test_select_box
+    page = @mech.get("http://localhost/form_test.html")
+    post_form = page.forms.find { |f| f.name == "post_form1" }
+
+    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_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 = @mech.submit(post_form, post_form.buttons.first)
+
+    # Check that the submitted fields exist
+    assert(page.links.find { |l| l.text == "country:CANADA" },
+           "select box not submitted")
+  end
+
+  def test_get
+    page = @mech.get("http://localhost/form_test.html")
+    get_form = page.forms.find { |f| f.name == "get_form1" }
+
+    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(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" }
+    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 = @mech.submit(get_form, get_form.buttons.first)
+
+    # Check that the submitted fields exist
+    assert_equal(6, page.links.size, "Not enough links")
+    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_reset
+    page = @mech.get("http://localhost/form_test.html")
+    get_form = page.forms.find { |f| f.name == "get_form1" }
+
+    image_button = get_form.buttons.first
+    submit_button = get_form.submits.first
+
+    new_page = @mech.submit(get_form, submit_button)
+    assert_equal "http://localhost/form_post?first_name=", new_page.uri.to_s
+
+    new_page = @mech.submit(get_form, image_button)
+    assert_equal "http://localhost/form_post?first_name=&button.x=0&button.y=0", new_page.uri.to_s
+
+    get_form.reset
+
+    new_page = @mech.submit(get_form, submit_button)
+    assert_equal "http://localhost/form_post?first_name=", new_page.uri.to_s
+  end
+
+  def test_post_with_space_in_action
+    page = @mech.get("http://localhost/form_test.html")
+    post_form = page.forms.find { |f| f.name == "post_form2" }
+
+    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(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"
+    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 = @mech.submit(post_form, post_form.buttons.first)
+
+    # Check that the submitted fields exist
+    assert_equal(3, page.links.size, "Not enough links")
+    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 = @mech.get("http://localhost/form_test.html")
+    get_form = page.forms.find { |f| f.name == "get_form2" }
+
+    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(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"
+    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 = @mech.submit(get_form, get_form.buttons.first)
+
+    # Check that the submitted fields exist
+    assert_equal(3, page.links.size, "Not enough links")
+    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 = @mech.get("http://localhost/form_test.html")
+    post_form = page.forms.find { |f| f.name == "post_form3" }
+
+    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(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(male_button, "Gender male button was nil")
+
+    female_button = post_form.radiobuttons.find { |f|
+      f.name == "gender" && f.value == "female"
+    }
+
+    assert(female_button, "Gender female button was nil")
+
+    assert(post_form.checkbox_with(: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.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 = @mech.submit(post_form, post_form.buttons.first)
+
+    # Check that the submitted fields exist
+    assert_equal(3, page.links.size, "Not enough links")
+
+    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 = @mech.get("http://localhost/form_test.html")
+    get_form = page.forms.find { |f| f.name == "get_form3" }
+
+    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(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"
+    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 = @mech.submit(get_form, get_form.buttons.first)
+    # Check that the submitted fields exist
+    assert_equal(3, page.links.size, "Not enough links")
+    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
+    page = @mech.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 = @mech.get("http://localhost/form_multival.html")
+    form = page.form_with(:name => 'post_form')
+
+    assert_equal(2, form.fields_with(:name => 'first').length)
+
+    form.first = 'Aaron'
+    assert_equal('Aaron', form.first)
+  end
+
+  def test_form_and_fields_dom_id
+    # blatant copypasta of test above
+    page = @mech.get("http://localhost/form_test.html")
+    form = page.form_with(dom_id: 'generic_form')
+
+    assert_equal(1, form.fields_with(dom_id: 'name_first').length)
+    assert_equal('first_name', form.field_with(dom_id: 'name_first').name)
+
+    assert_equal(form, page.form_with(id: 'generic_form'))
+    assert_equal(form, page.form_with(css: '#generic_form'))
+
+    fields_by_dom_id = form.fields_with(dom_id: 'name_first')
+    assert_equal(fields_by_dom_id, form.fields_with(id: 'name_first'))
+    assert_equal(fields_by_dom_id, form.fields_with(css: '#name_first'))
+    assert_equal(fields_by_dom_id, form.fields_with(xpath: '//*[@id="name_first"]'))
+    assert_equal(fields_by_dom_id, form.fields_with(search: '//*[@id="name_first"]'))
+  end
+
+  def test_form_and_fields_dom_class
+    # blatant copypasta of test above
+    page = @mech.get("http://localhost/form_test.html")
+    form = page.form_with(:dom_class => 'really_generic_form')
+    form_by_class = page.form_with(:class => 'really_generic_form')
+
+    assert_equal(1, form.fields_with(:dom_class => 'text_input').length)
+    assert_equal('first_name', form.field_with(:dom_class => 'text_input').name)
+
+    #  *_with(:class => blah) should work exactly like (:dom_class => blah)
+    assert_equal(form, form_by_class)
+    assert_equal(form.fields_with(:dom_class => 'text_input'), form.fields_with(:class => 'text_input'))
+  end
+
+  def test_add_field
+    page = @mech.get("http://localhost/form_multival.html")
+    form = page.form_with(:name => 'post_form')
+
+    number_of_fields = form.fields.length
+
+    assert form.add_field!('intarweb')
+    assert_equal(number_of_fields + 1, form.fields.length)
+  end
+
+  def test_delete_field
+    page = @mech.get("http://localhost/form_multival.html")
+    form = page.form_with(:name => 'post_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 = @mech.get("http://localhost/form_multival.html")
+    form = page.form_with(:name => 'post_form')
+
+    assert_equal false, form.has_field?('intarweb')
+    assert form.add_field!('intarweb')
+    assert_equal true, form.has_field?('intarweb')
+  end
+
+  def test_fill_unexisting_form
+    page = @mech.get("http://localhost/empty_form.html")
+    assert_raises(NoMethodError) {
+      page.form_with(:name => 'no form') { |f| f.foo = 'bar' }
+    }
+    begin
+      page.form_with!(:name => 'no form') { |f| f.foo = 'bar' }
+    rescue => e
+      assert_instance_of Mechanize::ElementNotFoundError, e
+      assert_kind_of Mechanize::Page, e.source
+      assert_equal :form, e.element
+      assert_kind_of Hash, e.conditions
+      assert_equal 'no form', e.conditions[:name]
+    end
+  end
+
+  def test_field_error
+    @page = @mech.get('http://localhost/empty_form.html')
+    form = @page.forms.first
+    assert_raises(NoMethodError) {
+      form.foo = 'asdfasdf'
+    }
+
+    assert_raises(NoMethodError) {
+      form.foo
+    }
+  end
+
+  def test_form_build_query
+    page = @mech.get("http://localhost/form_order_test.html")
+    get_form = page.forms.first
+
+    query = get_form.build_query
+
+    expected = [
+      %w[1 RADIO],
+      %w[3 nobody@example],
+      %w[2 TEXT],
+      %w[3 2011-10],
+    ]
+
+    assert_equal expected, query
+  end
+
+  def test_form_input_disabled
+    page = html_page <<-BODY
+<form name="form1" method="post" action="/form_post">
+  <input type="text" name="opa" value="omg" disabled />
+  <input type="submit" value="Submit" />
+</form>
+    BODY
+    form = page.forms.first
+
+    page = @mech.submit form
+
+    assert_empty page.links
+  end
+
+  def test_form_built_from_array_post
+    submitted = @mech.post(
+      'http://example/form_post',
+      [
+        %w[order_matters 0],
+        %w[order_matters 1],
+        %w[order_matters 2],
+        %w[mess_it_up asdf]
+      ]
+    )
+
+    assert_equal 'order_matters=0&order_matters=1&order_matters=2&mess_it_up=asdf', submitted.parser.at('#query').text
+  end
+
+  def test_form_built_from_hashes_submit
+    uri = URI 'http://example/form_post'
+    page = page uri
+    form = Mechanize::Form.new node('form', 'name' => @NAME, 'method' => 'POST'), @mech, page
+    form.fields << Mechanize::Form::Field.new({'name' => 'order_matters'}, '0')
+    form.fields << Mechanize::Form::Field.new({'name' => 'order_matters'}, '1')
+    form.fields << Mechanize::Form::Field.new({'name' => 'order_matters'}, '2')
+    form.fields << Mechanize::Form::Field.new({'name' => 'mess_it_up'}, 'asdf')
+
+    submitted = @mech.submit form
+
+    assert_equal 'order_matters=0&order_matters=1&order_matters=2&mess_it_up=asdf', submitted.parser.at('#query').text
+  end
+
+end