mechanize 2.0.1 → 2.1.pre.1

data/test/test_mechanize_download.rb

@@ -0,0 +1,43 @@
+require 'mechanize/test_case'
+
+class TestMechanizeDownload < Mechanize::TestCase
+
+  def setup
+    super
+
+    @parser = Mechanize::Download
+  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
+      download.save
+
+      assert File.exist? 'foo.html'
+    end
+  end
+
+  def test_save_tempfile
+    uri = URI.parse 'http://example/foo.html'
+    Tempfile.new __name__ do |body_io|
+      body_io.write '0123456789'
+
+      body_io.flush
+      body_io.rewind
+
+      download = @parser.new uri, nil, body_io
+
+      in_tmpdir do
+        download.save
+
+        assert File.exist? 'foo.html'
+      end
+    end
+  end
+
+end
+

data/test/test_mechanize_file.rb

@@ -1,53 +1,61 @@
-require "helper"
-
-class TestMechanizeFile < MiniTest::Unit::TestCase
-  def test_content_disposition
-    file = Mechanize::File.new(
-                                    URI.parse('http://localhost/foo'),
-           { 'content-disposition' => 'attachment; filename=genome.jpeg; modification-date="Wed, 12 Feb 1997 16:29:51 -0500"', }
-           )
-    assert_equal('genome.jpeg', file.filename)
-
-    file = Mechanize::File.new(
-                                    URI.parse('http://localhost/foo'),
-           { 'content-disposition' => 'filename=genome.jpeg; modification-date="Wed, 12 Feb 1997 16:29:51 -0500"', }
-           )
-    assert_equal('genome.jpeg', file.filename)
-
-    file = Mechanize::File.new(
-                                    URI.parse('http://localhost/foo'),
-           { 'content-disposition' => 'filename=genome.jpeg', }
-           )
-    assert_equal('genome.jpeg', file.filename)
+require 'mechanize/test_case'
+
+class TestMechanizeFile < Mechanize::TestCase
+
+  def setup
+    super
+
+    @parser = Mechanize::File
   end
 
-  def test_content_disposition_double_semicolon
-    agent = Mechanize.new
-    page = agent.get("http://localhost/http_headers?content-disposition=#{CGI.escape('attachment;; filename=fooooo')}")
-    assert page.parser
+  def test_save
+    uri = URI 'http://example/name.html'
+    page = Mechanize::File.new uri, nil, '0123456789'
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do
+        page.save 'test.html'
+
+        assert_equal '0123456789', File.read('test.html')
+      end
+    end
   end
 
-  def test_from_uri
-    file = Mechanize::File.new(
-                                    URI.parse('http://localhost/foo'),
-                                    {}
-           )
-    assert_equal('foo.html', file.filename)
-
-    file = Mechanize::File.new(
-                                    URI.parse('http://localhost/foo.jpg'),
-                                    {}
-           )
-    assert_equal('foo.jpg', file.filename)
-
-    file = Mechanize::File.new(
-                                    URI.parse('http://localhost/foo.jpg')
-           )
-    assert_equal('foo.jpg', file.filename)
+  def test_save_default
+    uri = URI 'http://example/test.html'
+    page = Mechanize::File.new uri, nil, ''
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do
+        page.save
+
+        assert File.exist? 'test.html'
+
+        page.save
+
+        assert File.exist? 'test.html.1'
+
+        page.save
+
+        assert File.exist? 'test.html.2'
+      end
+    end
   end
 
-  def test_no_uri
-    file = Mechanize::File.new()
-    assert_equal('index.html', file.filename)
+  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
+        page.save
+        assert File.exist? 'test.html'
+
+        page.save
+        assert File.exist? 'test.html.1'
+      end
+    end
   end
+
 end
+

data/test/{test_mechanize_file_response.rb → test_mechanize_file_connection.rb}

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

data/test/test_mechanize_file_request.rb

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

data/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/test/test_mechanize_form.rb

@@ -1,28 +1,137 @@
-require "helper"
+require 'mechanize/test_case'
 
-class TestMechanizeForm < MiniTest::Unit::TestCase
+class TestMechanizeForm < Mechanize::TestCase
 
   def setup
-    @agent = Mechanize.new
+    super
+
+    @form = Mechanize::Form.new node 'form'
+  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_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 = @agent.get('http://localhost/tc_blank_form.html')
+    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_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 = @agent.get('http://localhost/form_no_input_name.html')
+    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 = @agent.get("http://localhost/google.html")
+    page = @mech.get("http://localhost/google.html")
     search = page.forms.find { |f| f.name == "f" }
 
     assert(search.field_with(:name => 'q'))
@@ -31,26 +140,50 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_fields_no_input_name
-    page = @agent.get('http://localhost/form_no_input_name.html')
+    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 = @agent.get("http://localhost/file_upload.html")
+    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 = @agent.get('http://localhost/form_no_input_name.html')
+    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 @form.has_field?('name')
+  end
+
+  def test_has_value_eh
+    refute @form.has_value? 'Aaron'
+
+    @form['name'] = 'Aaron'
+
+    assert @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>
@@ -58,7 +191,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
 </form>
     FORM
 
-    form = Mechanize::Form.new form, @agent
+    form = Mechanize::Form.new form, @mech
     textarea = form.fields.first
 
     assert_kind_of Mechanize::Form::Textarea, textarea
@@ -66,27 +199,93 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_post_with_rails_3_encoding_hack
-    page = @agent.get("http://localhost/rails_3_encoding_hack_form_test.html")
+    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 = @agent.get("http://localhost/form_test.html")
+    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 = @agent.get('http://localhost:2000/form_no_action.html')
+    page = @mech.get('http://localhost:2000/form_no_action.html')
     page.forms.first.fields.first.value = 'Aaron'
-    page = @agent.submit(page.forms.first)
+    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 = @agent.get('http://localhost/tc_field_precedence.html')
+    page = @mech.get('http://localhost/tc_field_precedence.html')
     form = page.forms.first
 
     assert !form.checkboxes.empty?
@@ -98,10 +297,10 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_submit_takes_arbirary_headers
-    page = @agent.get('http://localhost:2000/form_no_action.html')
+    page = @mech.get('http://localhost:2000/form_no_action.html')
     assert form = page.forms.first
     form.action = '/http_headers'
-    page = @agent.submit(form, nil, { 'foo' => 'bar' })
+    page = @mech.submit(form, nil, { 'foo' => 'bar' })
 
     headers = page.body.split("\n").map { |x| x.split('|', 2) }.flatten
     headers = Hash[*headers]
@@ -109,9 +308,78 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
     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 = @agent.get("http://localhost/form_multival.html")
+    page = @mech.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'post_form')
 
     assert_equal(2, form.fields_with(:name => 'first').length)
@@ -119,7 +387,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
     form.fields_with(:name => 'first')[0].value = 'Aaron'
     form.fields_with(:name => 'first')[1].value = 'Patterson'
 
-    page = @agent.submit(form)
+    page = @mech.submit(form)
 
     assert_equal(2, page.links.length)
     assert(page.link_with(:text => 'first:Aaron'))
@@ -128,7 +396,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
 
   # Test calling submit on the form object
   def test_submit_on_form
-    page = @agent.get("http://localhost/form_multival.html")
+    page = @mech.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'post_form')
 
     assert_equal(2, form.fields_with(:name => 'first').length)
@@ -145,7 +413,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
 
   # Test submitting form with two fields of the same name
   def test_get_multival
-    page = @agent.get("http://localhost/form_multival.html")
+    page = @mech.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'get_form')
 
     assert_equal(2, form.fields_with(:name => 'first').length)
@@ -153,7 +421,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
     form.fields_with(:name => 'first')[0].value = 'Aaron'
     form.fields_with(:name => 'first')[1].value = 'Patterson'
 
-    page = @agent.submit(form)
+    page = @mech.submit(form)
 
     assert_equal(2, page.links.length)
     assert(page.link_with(:text => 'first:Aaron'))
@@ -161,14 +429,14 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_post_with_non_strings
-    page = @agent.get("http://localhost/form_test.html")
+    page = @mech.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")
+    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)
@@ -212,7 +480,7 @@ class TestMechanizeForm < MiniTest::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 = @mech.submit(post_form, post_form.buttons.first)
 
     # Check that the submitted fields exist
     assert_equal(5, page.links.size, "Not enough links")
@@ -229,7 +497,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_post_multipart
-    page = @agent.get("http://localhost/form_test.html")
+    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)
@@ -238,13 +506,13 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
     assert_equal(1, post_form.fields.size)
     assert_equal(1, post_form.buttons.size)
 
-    page = @agent.submit(post_form, post_form.buttons.first)
+    page = @mech.submit(post_form, post_form.buttons.first)
 
     assert page
   end
 
   def test_select_box
-    page = @agent.get("http://localhost/form_test.html")
+    page = @mech.get("http://localhost/form_test.html")
     post_form = page.forms.find { |f| f.name == "post_form1" }
 
     assert(page.header)
@@ -266,7 +534,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
     # 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)
+    page = @mech.submit(post_form, post_form.buttons.first)
 
     # Check that the submitted fields exist
     assert(page.links.find { |l| l.text == "country:CANADA" },
@@ -274,7 +542,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_get
-    page = @agent.get("http://localhost/form_test.html")
+    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)
@@ -309,7 +577,7 @@ class TestMechanizeForm < MiniTest::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 = @mech.submit(get_form, get_form.buttons.first)
 
     # Check that the submitted fields exist
     assert_equal(6, page.links.size, "Not enough links")
@@ -328,7 +596,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_post_with_space_in_action
-    page = @agent.get("http://localhost/form_test.html")
+    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)
@@ -356,7 +624,7 @@ class TestMechanizeForm < MiniTest::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 = @mech.submit(post_form, post_form.buttons.first)
 
     # Check that the submitted fields exist
     assert_equal(3, page.links.size, "Not enough links")
@@ -369,7 +637,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_get_with_space_in_action
-    page = @agent.get("http://localhost/form_test.html")
+    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)
@@ -397,7 +665,7 @@ class TestMechanizeForm < MiniTest::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 = @mech.submit(get_form, get_form.buttons.first)
 
     # Check that the submitted fields exist
     assert_equal(3, page.links.size, "Not enough links")
@@ -410,7 +678,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_post_with_param_in_action
-    page = @agent.get("http://localhost/form_test.html")
+    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)
@@ -447,7 +715,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
     }.checked = true
     post_form.checkboxes.find { |f| f.name == "likes ham" }.checked = true
 
-    page = @agent.submit(post_form, post_form.buttons.first)
+    page = @mech.submit(post_form, post_form.buttons.first)
 
     # Check that the submitted fields exist
     assert_equal(3, page.links.size, "Not enough links")
@@ -461,7 +729,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_get_with_param_in_action
-    page = @agent.get("http://localhost/form_test.html")
+    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)
@@ -489,7 +757,7 @@ class TestMechanizeForm < MiniTest::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 = @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" },
@@ -501,14 +769,14 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_field_addition
-    page = @agent.get("http://localhost/form_test.html")
+    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 = @agent.get("http://localhost/form_multival.html")
+    page = @mech.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'post_form')
 
     assert_equal(2, form.fields_with(:name => 'first').length)
@@ -519,7 +787,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
 
   def test_form_and_fields_dom_id
     # blatant copypasta of test above
-    page = @agent.get("http://localhost/form_test.html")
+    page = @mech.get("http://localhost/form_test.html")
     form = page.form_with(:dom_id => 'generic_form')
     form_by_id = page.form_with(:id => 'generic_form')
 
@@ -531,8 +799,22 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
     assert_equal(form.fields_with(:dom_id => 'name_first'), form.fields_with(: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 = @agent.get("http://localhost/form_multival.html")
+    page = @mech.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'post_form')
 
     number_of_fields = form.fields.length
@@ -542,7 +824,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_delete_field
-    page = @agent.get("http://localhost/form_multival.html")
+    page = @mech.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'post_form')
 
     number_of_fields = form.fields.length
@@ -554,7 +836,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_has_field
-    page = @agent.get("http://localhost/form_multival.html")
+    page = @mech.get("http://localhost/form_multival.html")
     form = page.form_with(:name => 'post_form')
 
     assert(!form.has_field?('intarweb'))
@@ -563,7 +845,7 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
   end
 
   def test_field_error
-    @page = @agent.get('http://localhost/empty_form.html')
+    @page = @mech.get('http://localhost/empty_form.html')
     form = @page.forms.first
     assert_raises(NoMethodError) {
       form.foo = 'asdfasdf'
@@ -573,4 +855,21 @@ class TestMechanizeForm < MiniTest::Unit::TestCase
       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
+
 end