RubyGems - diamond-mechanize - Versions diffs - 2.1 → 2.2 - Mend

diamond-mechanize 2.1 → 2.2

Files changed (147) hide show

metadata +222 -167
data/Rakefile +0 -49
data/lib/mechanize/content_type_error.rb +0 -13
data/lib/mechanize/cookie.rb +0 -232
data/lib/mechanize/cookie_jar.rb +0 -194
data/lib/mechanize/download.rb +0 -59
data/lib/mechanize/element_matcher.rb +0 -36
data/lib/mechanize/file.rb +0 -65
data/lib/mechanize/file_connection.rb +0 -17
data/lib/mechanize/file_request.rb +0 -26
data/lib/mechanize/file_response.rb +0 -74
data/lib/mechanize/file_saver.rb +0 -39
data/lib/mechanize/form/button.rb +0 -6
data/lib/mechanize/form/check_box.rb +0 -12
data/lib/mechanize/form/field.rb +0 -54
data/lib/mechanize/form/file_upload.rb +0 -21
data/lib/mechanize/form/hidden.rb +0 -3
data/lib/mechanize/form/image_button.rb +0 -19
data/lib/mechanize/form/keygen.rb +0 -34
data/lib/mechanize/form/multi_select_list.rb +0 -94
data/lib/mechanize/form/option.rb +0 -50
data/lib/mechanize/form/radio_button.rb +0 -55
data/lib/mechanize/form/reset.rb +0 -3
data/lib/mechanize/form/select_list.rb +0 -44
data/lib/mechanize/form/submit.rb +0 -3
data/lib/mechanize/form/text.rb +0 -3
data/lib/mechanize/form/textarea.rb +0 -3
data/lib/mechanize/form.rb +0 -543
data/lib/mechanize/headers.rb +0 -23
data/lib/mechanize/history.rb +0 -82
data/lib/mechanize/http/agent.rb +0 -1004
data/lib/mechanize/http/auth_challenge.rb +0 -59
data/lib/mechanize/http/auth_realm.rb +0 -31
data/lib/mechanize/http/content_disposition_parser.rb +0 -188
data/lib/mechanize/http/www_authenticate_parser.rb +0 -155
data/lib/mechanize/http.rb +0 -8
data/lib/mechanize/monkey_patch.rb +0 -16
data/lib/mechanize/page/base.rb +0 -7
data/lib/mechanize/page/frame.rb +0 -27
data/lib/mechanize/page/image.rb +0 -30
data/lib/mechanize/page/label.rb +0 -20
data/lib/mechanize/page/link.rb +0 -98
data/lib/mechanize/page/meta_refresh.rb +0 -68
data/lib/mechanize/page.rb +0 -440
data/lib/mechanize/parser.rb +0 -173
data/lib/mechanize/pluggable_parsers.rb +0 -144
data/lib/mechanize/redirect_limit_reached_error.rb +0 -19
data/lib/mechanize/redirect_not_get_or_head_error.rb +0 -21
data/lib/mechanize/response_code_error.rb +0 -21
data/lib/mechanize/response_read_error.rb +0 -27
data/lib/mechanize/robots_disallowed_error.rb +0 -28
data/lib/mechanize/test_case.rb +0 -663
data/lib/mechanize/unauthorized_error.rb +0 -3
data/lib/mechanize/unsupported_scheme_error.rb +0 -6
data/lib/mechanize/util.rb +0 -101
data/lib/mechanize.rb +0 -1079
data/test/data/htpasswd +0 -1
data/test/data/server.crt +0 -16
data/test/data/server.csr +0 -12
data/test/data/server.key +0 -15
data/test/data/server.pem +0 -15
data/test/htdocs/alt_text.html +0 -10
data/test/htdocs/bad_form_test.html +0 -9
data/test/htdocs/button.jpg +0 -0
data/test/htdocs/canonical_uri.html +0 -9
data/test/htdocs/dir with spaces/foo.html +0 -1
data/test/htdocs/empty_form.html +0 -6
data/test/htdocs/file_upload.html +0 -26
data/test/htdocs/find_link.html +0 -41
data/test/htdocs/form_multi_select.html +0 -16
data/test/htdocs/form_multival.html +0 -37
data/test/htdocs/form_no_action.html +0 -18
data/test/htdocs/form_no_input_name.html +0 -16
data/test/htdocs/form_order_test.html +0 -11
data/test/htdocs/form_select.html +0 -16
data/test/htdocs/form_set_fields.html +0 -14
data/test/htdocs/form_test.html +0 -188
data/test/htdocs/frame_referer_test.html +0 -10
data/test/htdocs/frame_test.html +0 -30
data/test/htdocs/google.html +0 -13
data/test/htdocs/index.html +0 -6
data/test/htdocs/link with space.html +0 -5
data/test/htdocs/meta_cookie.html +0 -11
data/test/htdocs/no_title_test.html +0 -6
data/test/htdocs/noindex.html +0 -9
data/test/htdocs/rails_3_encoding_hack_form_test.html +0 -27
data/test/htdocs/relative/tc_relative_links.html +0 -21
data/test/htdocs/robots.html +0 -8
data/test/htdocs/robots.txt +0 -2
data/test/htdocs/tc_bad_charset.html +0 -9
data/test/htdocs/tc_bad_links.html +0 -5
data/test/htdocs/tc_base_link.html +0 -8
data/test/htdocs/tc_blank_form.html +0 -11
data/test/htdocs/tc_charset.html +0 -6
data/test/htdocs/tc_checkboxes.html +0 -19
data/test/htdocs/tc_encoded_links.html +0 -5
data/test/htdocs/tc_field_precedence.html +0 -11
data/test/htdocs/tc_follow_meta.html +0 -8
data/test/htdocs/tc_form_action.html +0 -48
data/test/htdocs/tc_links.html +0 -19
data/test/htdocs/tc_meta_in_body.html +0 -9
data/test/htdocs/tc_pretty_print.html +0 -17
data/test/htdocs/tc_referer.html +0 -16
data/test/htdocs/tc_relative_links.html +0 -19
data/test/htdocs/tc_textarea.html +0 -23
data/test/htdocs/test_click.html +0 -11
data/test/htdocs/unusual______.html +0 -5
data/test/test_mechanize.rb +0 -1164
data/test/test_mechanize_cookie.rb +0 -451
data/test/test_mechanize_cookie_jar.rb +0 -483
data/test/test_mechanize_download.rb +0 -43
data/test/test_mechanize_file.rb +0 -61
data/test/test_mechanize_file_connection.rb +0 -21
data/test/test_mechanize_file_request.rb +0 -19
data/test/test_mechanize_file_saver.rb +0 -21
data/test/test_mechanize_form.rb +0 -875
data/test/test_mechanize_form_check_box.rb +0 -38
data/test/test_mechanize_form_encoding.rb +0 -114
data/test/test_mechanize_form_field.rb +0 -63
data/test/test_mechanize_form_file_upload.rb +0 -20
data/test/test_mechanize_form_image_button.rb +0 -12
data/test/test_mechanize_form_keygen.rb +0 -32
data/test/test_mechanize_form_multi_select_list.rb +0 -84
data/test/test_mechanize_form_option.rb +0 -55
data/test/test_mechanize_form_radio_button.rb +0 -78
data/test/test_mechanize_form_select_list.rb +0 -76
data/test/test_mechanize_form_textarea.rb +0 -52
data/test/test_mechanize_headers.rb +0 -35
data/test/test_mechanize_history.rb +0 -103
data/test/test_mechanize_http_agent.rb +0 -1225
data/test/test_mechanize_http_auth_challenge.rb +0 -39
data/test/test_mechanize_http_auth_realm.rb +0 -49
data/test/test_mechanize_http_content_disposition_parser.rb +0 -118
data/test/test_mechanize_http_www_authenticate_parser.rb +0 -146
data/test/test_mechanize_link.rb +0 -80
data/test/test_mechanize_page.rb +0 -118
data/test/test_mechanize_page_encoding.rb +0 -182
data/test/test_mechanize_page_frame.rb +0 -16
data/test/test_mechanize_page_link.rb +0 -390
data/test/test_mechanize_page_meta_refresh.rb +0 -127
data/test/test_mechanize_parser.rb +0 -289
data/test/test_mechanize_pluggable_parser.rb +0 -52
data/test/test_mechanize_redirect_limit_reached_error.rb +0 -24
data/test/test_mechanize_redirect_not_get_or_head_error.rb +0 -14
data/test/test_mechanize_subclass.rb +0 -22
data/test/test_mechanize_util.rb +0 -103
data/test/test_multi_select.rb +0 -119

data/test/htdocs/unusual______.html DELETED Viewed

@@ -1,5 +0,0 @@
-<html>
-  <body>
-    This is a webpage that has a very unusual name.
-  </body>
-</html>

data/test/test_mechanize.rb DELETED Viewed

@@ -1,1164 +0,0 @@
-# coding: utf-8
-require 'mechanize/test_case'
-class TestMechanize < Mechanize::TestCase
-  def setup
-    super
-    @uri = URI 'http://example/'
-    @req = Net::HTTP::Get.new '/'
-    @res = Net::HTTPOK.allocate
-    @res.instance_variable_set :@code, 200
-    @res.instance_variable_set :@header, {}
-    @headers = if RUBY_VERSION > '1.9' then
-                 %w[accept user-agent]
-               else
-                 %w[accept]
-               end
-  end
-  def test_back
-    0.upto(5) do |i|
-      assert_equal(i, @mech.history.size)
-      @mech.get("http://localhost/")
-    end
-    @mech.get("http://localhost/form_test.html")
-    assert_equal("http://localhost/form_test.html",
-      @mech.history.last.uri.to_s)
-    assert_equal("http://localhost/",
-      @mech.history[-2].uri.to_s)
-    assert_equal(7, @mech.history.size)
-    @mech.back
-    assert_equal(6, @mech.history.size)
-    assert_equal("http://localhost/",
-      @mech.history.last.uri.to_s)
-  end
-  def test_basic_auth
-    @mech.basic_auth('user', 'pass')
-    page = @mech.get("http://localhost/basic_auth")
-    assert_equal('You are authenticated', page.body)
-  end
-  def test_cert_key_file
-    in_tmpdir do
-      open 'key.pem', 'w'  do |io| io.write ssl_private_key.to_pem end
-      open 'cert.pem', 'w' do |io| io.write ssl_certificate.to_pem end
-      mech = Mechanize.new do |a|
-        a.cert = 'cert.pem'
-        a.key  = 'key.pem'
-      end
-      # Certificate#== seems broken
-      assert_equal ssl_certificate.to_pem, mech.certificate.to_pem
-    end
-  end
-  def test_cert_key_object
-    mech = Mechanize.new do |a|
-      a.cert = ssl_certificate
-      a.key  = ssl_private_key
-    end
-    assert_equal ssl_certificate, mech.certificate
-  end
-  def test_cert_store
-    assert_nil @mech.cert_store
-    store = OpenSSL::X509::Store.new
-    @mech.cert_store = store
-    assert_equal store, @mech.cert_store
-  end
-  def test_click
-    @mech.user_agent_alias = 'Mac Safari'
-    page = @mech.get("http://localhost/frame_test.html")
-    link = page.link_with(:text => "Form Test")
-    page = @mech.click(link)
-    assert_equal("http://localhost/form_test.html",
-                 @mech.history.last.uri.to_s)
-  end
-  def test_click_frame
-    frame = node 'frame', 'src' => '/index.html'
-    frame = Mechanize::Page::Frame.new frame, @mech, fake_page
-    @mech.click frame
-    assert_equal '/index.html', requests.first.path
-  end
-  def test_click_frame_hpricot_style
-    page = @mech.get("http://localhost/frame_test.html")
-    link = (page/"//frame[@name='frame2']").first
-    page = @mech.click(link)
-    assert_equal("http://localhost/form_test.html",
-                 @mech.history.last.uri.to_s)
-  end
-  def test_click_hpricot_style # HACK move to test_divide in Page
-    page = @mech.get("http://localhost/frame_test.html")
-    link = (page/"//a[@class='bar']").first
-    page = @mech.click(link)
-    assert_equal("http://localhost/form_test.html",
-                 @mech.history.last.uri.to_s)
-  end
-  def test_click_link
-    link = node 'a', 'href' => '/index.html'
-    link = Mechanize::Page::Link.new link, @mech, fake_page
-    @mech.click link
-    assert_equal '/index.html', requests.first.path
-    assert_equal 'http://fake.example/', requests.first['Referer']
-  end
-  def test_click_link_nofollow
-    page = html_page <<-BODY
-<meta name="ROBOTS" content="nofollow">
-<p>Do not follow <a href="/index.html">this</a> or <a href="/">this</a>!
-    BODY
-    page.links[0].click
-    page.links[1].click
-    @mech.robots = true
-    assert_raises Mechanize::RobotsDisallowedError do
-      page.links[0].click
-    end
-    assert_raises Mechanize::RobotsDisallowedError do
-      page.links[1].click
-    end
-  end
-  def test_click_link_noreferrer
-    link = node 'a', 'href' => '/index.html', 'rel' => 'noreferrer'
-    link = Mechanize::Page::Link.new link, @mech, fake_page
-    @mech.click link
-    assert_nil requests.first['referer']
-  end
-  def test_click_link_rel_nofollow
-    page = html_page <<-BODY
-<p>You can follow <a href="/index.html">this link</a>
-but not <a href="/" rel="me nofollow">this</a>!
-    BODY
-    page.links[0].click
-    page.links[1].click
-    @mech.robots = true
-    page.links[0].click
-    assert_raises Mechanize::RobotsDisallowedError do
-      page.links[1].click
-    end
-  end
-  def test_click_link_parent
-    page = page URI 'http://example/a/index.html'
-    link = node 'a', 'href' => '../index.html'
-    link = Mechanize::Page::Link.new link, @mech, page
-    @mech.click link
-    assert_equal '/index.html', requests.first.path
-  end
-  def test_click_link_parent_extra
-    page = page URI 'http://example/a/index.html'
-    link = node 'a', 'href' => '../../index.html'
-    link = Mechanize::Page::Link.new link, @mech, page
-    @mech.click link
-    assert_equal '/index.html', requests.first.path
-  end
-  def test_click_link_hpricot_style # HACK move to test_search in Page
-    page = @mech.get("http://localhost/tc_encoded_links.html")
-    page = @mech.click(page.search('a').first)
-    assert_equal("http://localhost/form_post?a=b&b=c", page.uri.to_s)
-  end
-  def test_click_link_query
-    page = @mech.get("http://localhost/tc_encoded_links.html")
-    link = page.links.first
-    assert_equal('/form_post?a=b&b=c', link.href)
-    page = @mech.click(link)
-    assert_equal("http://localhost/form_post?a=b&b=c", page.uri.to_s)
-  end
-  def test_click_link_space
-    page = @mech.get("http://localhost/tc_bad_links.html")
-    @mech.click page.links.first
-    assert_match(/alt_text.html$/, @mech.history.last.uri.to_s)
-    assert_equal(2, @mech.history.length)
-  end
-  def test_click_more
-    @mech.get 'http://localhost/test_click.html'
-    @mech.click 'A Button'
-    assert_equal 'http://localhost/frame_test.html?words=nil',
-      @mech.page.uri.to_s
-    @mech.back
-    @mech.click 'A Link'
-    assert_equal 'http://localhost/index.html',
-      @mech.page.uri.to_s
-    @mech.back
-    @mech.click @mech.page.link_with(:text => 'A Link')
-    assert_equal 'http://localhost/index.html',
-      @mech.page.uri.to_s
-  end
-  def test_cookies
-    uri = URI 'http://example'
-    jar = Mechanize::CookieJar.new
-    Mechanize::Cookie.parse uri, 'a=b' do |cookie|
-      jar.add uri, cookie
-    end
-    @mech.cookie_jar = jar
-    refute_empty @mech.cookies
-  end
-  def test_cookie_jar
-    assert_kind_of Mechanize::CookieJar, @mech.cookie_jar
-    jar = Mechanize::CookieJar.new
-    @mech.cookie_jar = jar
-    assert_equal jar, @mech.cookie_jar
-  end
-  def test_delete
-    page = @mech.delete('http://localhost/verb', { 'q' => 'foo' })
-    assert_equal 1, @mech.history.length
-    assert_equal 'DELETE', page.header['X-Request-Method']
-  end
-  def test_delete_redirect
-    page = @mech.delete('http://localhost/redirect')
-    assert_equal(page.uri.to_s, 'http://localhost/verb')
-    assert_equal 'GET', page.header['X-Request-Method']
-  end
-  #def test_download
-  #  Dir.mktmpdir do |dir|
-  #    file = "#{dir}/download"
-  #    open file, 'w' do |io|
-  #      @mech.download 'http://example', io
-  #    end
-  #    assert_equal 1, File.stat(file).size
-  #  end
-  #end
-  def test_get
-    uri = URI 'http://localhost'
-    page = @mech.get uri, { :q => 'h' }, 'http://example', { 'X-H' => 'v' }
-    assert_equal URI('http://localhost/?q=h'), page.uri
-    assert_equal URI('http://localhost'), uri
-  end
-  def test_get_HTTP
-    page = @mech.get('HTTP://localhost/', { :q => 'hello' })
-    assert_equal('HTTP://localhost/?q=hello', page.uri.to_s)
-  end
-  def test_get_anchor
-    page = @mech.get('http://localhost/?foo=bar&#34;')
-    assert_equal('http://localhost/?foo=bar%22', page.uri.to_s)
-  end
-  def test_get_bad_url
-    assert_raises ArgumentError do
-      @mech.get '/foo.html'
-    end
-  end
-  def test_get_basic_auth_bad
-    @mech.basic_auth('aaron', 'aaron')
-    e = assert_raises Mechanize::UnauthorizedError do
-      @mech.get("http://localhost/basic_auth")
-    end
-    assert_equal("401", e.response_code)
-  end
-  def test_get_basic_auth_none
-    e = assert_raises Mechanize::UnauthorizedError do
-      @mech.get("http://localhost/basic_auth")
-    end
-    assert_equal("401", e.response_code)
-  end
-  def test_get_conditional
-    assert_empty @mech.history
-    page = @mech.get 'http://localhost/if_modified_since'
-    assert_match(/You did not send/, page.body)
-    assert_equal 1, @mech.history.length
-    page2 = @mech.get 'http://localhost/if_modified_since'
-    assert_equal 2, @mech.history.length
-    assert_equal page.object_id, page2.object_id
-  end
-  def test_get_digest_auth
-    block_called = false
-    @mech.basic_auth('user', 'pass')
-    @mech.pre_connect_hooks << lambda { |_, request|
-      block_called = true
-      request.to_hash.each do |k,v|
-        assert_equal(1, v.length)
-      end
-    }
-    page = @mech.get("http://localhost/digest_auth")
-    assert_equal('You are authenticated', page.body)
-    assert block_called
-  end
-  def test_get_file
-    page = @mech.get("http://localhost/frame_test.html")
-    content_length = page.header['Content-Length']
-    page_as_string = @mech.get_file("http://localhost/frame_test.html")
-    assert_equal(content_length.to_i, page_as_string.length.to_i)
-  end
-  def test_get_follow_meta_refresh
-    @mech.follow_meta_refresh = true
-    page = @mech.get('http://localhost/tc_follow_meta.html')
-    assert_equal(2, @mech.history.length)
-    assert_equal('http://localhost/tc_follow_meta.html',
-                 @mech.history.first.uri.to_s)
-    assert_equal('http://localhost/index.html', page.uri.to_s)
-    assert_equal('http://localhost/index.html', @mech.history.last.uri.to_s)
-  end
-  def test_get_follow_meta_refresh_anywhere
-    @mech.follow_meta_refresh = :anywhere
-    requests = []
-    @mech.pre_connect_hooks << lambda { |_, request|
-      requests << request
-    }
-    @mech.get('http://localhost/tc_meta_in_body.html')
-    assert_equal 2, requests.length
-  end
-  def test_get_follow_meta_refresh_disabled
-    page = @mech.get('http://localhost/tc_follow_meta.html')
-    assert_equal('http://localhost/tc_follow_meta.html', page.uri.to_s)
-    assert_equal(1, page.meta_refresh.length)
-  end
-  def test_get_follow_meta_refresh_empty_url
-    @mech.follow_meta_refresh = true
-    @mech.follow_meta_refresh_self = true
-    page = @mech.get('http://localhost/refresh_with_empty_url')
-    assert_equal(3, @mech.history.length)
-    assert_equal('http://localhost/refresh_with_empty_url',
-                 @mech.history[0].uri.to_s)
-    assert_equal('http://localhost/refresh_with_empty_url',
-                 @mech.history[1].uri.to_s)
-    assert_equal('http://localhost/index.html', page.uri.to_s)
-    assert_equal('http://localhost/index.html', @mech.history.last.uri.to_s)
-  end
-  def test_get_follow_meta_refresh_in_body
-    @mech.follow_meta_refresh = true
-    requests = []
-    @mech.pre_connect_hooks << lambda { |_, request|
-      requests << request
-    }
-    @mech.get('http://localhost/tc_meta_in_body.html')
-    assert_equal 1, requests.length
-  end
-  def test_get_follow_meta_refresh_no_url
-    @mech.follow_meta_refresh = true
-    @mech.follow_meta_refresh_self = true
-    page = @mech.get('http://localhost/refresh_without_url')
-    assert_equal(3, @mech.history.length)
-    assert_equal('http://localhost/refresh_without_url',
-                 @mech.history[0].uri.to_s)
-    assert_equal('http://localhost/refresh_without_url',
-                 @mech.history[1].uri.to_s)
-    assert_equal('http://localhost/index.html', page.uri.to_s)
-    assert_equal('http://localhost/index.html', @mech.history.last.uri.to_s)
-  end
-  def test_get_follow_meta_refresh_referer_not_sent
-    @mech.follow_meta_refresh = true
-    requests = []
-    @mech.pre_connect_hooks << lambda { |_, request|
-      requests << request
-    }
-    @mech.get('http://localhost/tc_follow_meta.html')
-    assert_equal 2, @mech.history.length
-    assert_nil requests.last['referer']
-  end
-  def test_get_referer_download
-    download = Mechanize::Download.new URI 'http://example/prev'
-    uri = URI 'http://example'
-    page = @mech.get uri, { :q => 'h' }, download, { 'X-H' => 'v' }
-    assert_equal URI('http://example/?q=h'), page.uri
-    assert_equal URI('http://example'), uri
-    assert_equal 'http://example/prev', requests.first['referer']
-  end
-  def test_get_robots
-    @mech.robots = true
-    assert_equal "Page Title", @mech.get("http://localhost/index.html").title
-    assert_raises Mechanize::RobotsDisallowedError do
-      @mech.get "http://localhost/norobots.html"
-    end
-  end
-  def test_follow_meta_refresh_self
-    refute @mech.agent.follow_meta_refresh_self
-    @mech.follow_meta_refresh_self = true
-    assert @mech.agent.follow_meta_refresh_self
-  end
-  def test_get_gzip
-    page = @mech.get("http://localhost/gzip?file=index.html")
-    assert_kind_of(Mechanize::Page, page)
-    assert_match('Hello World', page.body)
-  end
-  def test_content_encoding_hooks_header
-    h = {'X-ResponseContentEncoding' => 'agzip'}
-    # test of X-ResponseContentEncoding feature
-    assert_raises(Mechanize::Error, 'Unsupported Content-Encoding: agzip') do
-      @mech.get("http://localhost/gzip?file=index.html", nil, nil, h)
-    end
-    @mech.content_encoding_hooks << lambda{|agent, uri, response, response_body_io|
-      response['content-encoding'] = 'gzip' if response['content-encoding'] == 'agzip'}
-    page = @mech.get("http://localhost/gzip?file=index.html", nil, nil, h)
-    assert_match('Hello World', page.body)
-  end
-  def external_cmd(io); Zlib::GzipReader.new(io).read; end
-  def test_content_encoding_hooks_body_io
-    h = {'X-ResponseContentEncoding' => 'unsupported_content_encoding'}
-   @mech.content_encoding_hooks << lambda{|agent, uri, response, response_body_io|
-      if response['content-encoding'] == 'unsupported_content_encoding'
-        response['content-encoding'] = 'none'
-        response_body_io.string = external_cmd(response_body_io)
-      end}
-    page = @mech.get("http://localhost/gzip?file=index.html", nil, nil, h)
-    assert_match('Hello World', page.body)
-  end
-  def test_get_http_refresh
-    @mech.follow_meta_refresh = true
-    requests = []
-    @mech.pre_connect_hooks << lambda { |_, request|
-      requests << request
-    }
-    page = @mech.get('http://localhost/http_refresh?refresh_time=0')
-    assert_equal('http://localhost/index.html', page.uri.to_s)
-    assert_equal(2, @mech.history.length)
-    assert_nil requests.last['referer']
-  end
-  def test_get_http_refresh_delay
-    @mech.follow_meta_refresh = true
-    class << @mech.agent
-      attr_accessor :slept
-      def sleep *args
-        @slept = args
-      end
-    end
-    @mech.get('http://localhost/http_refresh?refresh_time=1')
-    assert_equal [1], @mech.agent.slept
-  end
-  def test_get_http_refresh_disabled
-    page = @mech.get('http://localhost/http_refresh?refresh_time=0')
-    assert_equal('http://localhost/http_refresh?refresh_time=0', page.uri.to_s)
-  end
-  def test_get_kcode
-    $KCODE = 'u'
-    page = @mech.get("http://localhost/?a=#{[0xd6].pack('U')}")
-    assert_equal('http://localhost/?a=%D6', page.uri.to_s)
-    $KCODE = 'NONE'
-  end unless RUBY_VERSION >= '1.9.0'
-  def test_get_query
-    page = @mech.get('http://localhost/', { :q => 'hello' })
-    assert_equal('http://localhost/?q=hello', page.uri.to_s)
-  end
-  def test_get_redirect
-    page = @mech.get('http://localhost/redirect')
-    assert_equal(page.uri.to_s, 'http://localhost/verb')
-    assert_equal 'GET', page.header['X-Request-Method']
-  end
-  def test_get_redirect_found
-    page = @mech.get('http://localhost/response_code?code=302&ct=test/xml')
-    assert_equal('http://localhost/index.html', page.uri.to_s)
-    assert_equal(2, @mech.history.length)
-  end
-  def test_get_redirect_infinite
-    assert_raises(Mechanize::RedirectLimitReachedError) {
-      @mech.get('http://localhost/infinite_refresh')
-    }
-  end
-  def test_get_referer
-    request = nil
-    @mech.pre_connect_hooks << lambda { |_, req|
-      request = req
-    }
-    @mech.get('http://localhost/', [], 'http://tenderlovemaking.com/')
-    assert_equal 'http://tenderlovemaking.com/', request['Referer']
-  end
-  def test_get_referer_file
-    uri = URI 'http://tenderlovemaking.com/crossdomain.xml'
-    file = Mechanize::File.new uri
-    @mech.get('http://localhost', [], file)
-    # HACK no assertion of behavior
-  end
-  def test_get_referer_none
-    requests = []
-    @mech.pre_connect_hooks << lambda { |_, request|
-      requests << request
-    }
-    @mech.get('http://localhost/')
-    @mech.get('http://localhost/')
-    assert_equal(2, requests.length)
-    requests.each do |request|
-      assert_nil request['referer']
-    end
-  end
-  def test_get_scheme_unsupported
-    assert_raises Mechanize::UnsupportedSchemeError do
-      @mech.get('ftp://server.com/foo.html')
-    end
-  end
-  def test_get_space
-    page = nil
-    page = @mech.get("http://localhost/tc_bad_links.html ")
-    assert_match(/tc_bad_links.html$/, @mech.history.last.uri.to_s)
-    assert_equal(1, @mech.history.length)
-  end
-  def test_get_tilde
-    page = @mech.get('http://localhost/?foo=~2')
-    assert_equal('http://localhost/?foo=~2', page.uri.to_s)
-  end
-  def test_get_weird
-    @mech.get('http://localhost/?action=bing&bang=boom=1|a=|b=|c=')
-    @mech.get('http://localhost/?a=b&#038;b=c&#038;c=d')
-    @mech.get("http://localhost/?a=#{[0xd6].pack('U')}")
-    # HACK no assertion of behavior
-  end
-  def test_get_yield
-    pages = nil
-    @mech.get("http://localhost/file_upload.html") { |page|
-      pages = page
-    }
-    assert pages
-    assert_equal('File Upload Form', pages.title)
-  end
-  def test_head
-    page = @mech.head('http://localhost/verb', { 'q' => 'foo' })
-    assert_equal 0, @mech.history.length
-    assert_equal 'HEAD', page.header['X-Request-Method']
-  end
-  def test_head_redirect
-    page = @mech.head('http://localhost/redirect')
-    assert_equal(page.uri.to_s, 'http://localhost/verb')
-    assert_equal 'HEAD', page.header['X-Request-Method']
-  end
-  def test_history
-    2.times do |i|
-      assert_equal(i, @mech.history.size)
-      @mech.get("http://localhost/")
-    end
-    page = @mech.get("http://localhost/form_test.html")
-    assert_equal("http://localhost/form_test.html",
-      @mech.history.last.uri.to_s)
-    assert_equal("http://localhost/",
-      @mech.history[-2].uri.to_s)
-    assert @mech.visited?("http://localhost/")
-    assert @mech.visited?("/form_test.html"), 'relative'
-    assert !@mech.visited?("http://google.com/")
-    assert @mech.visited?(page.links.first)
-  end
-  def test_history_added_gets_called
-    added_page = nil
-    @mech.history_added = lambda { |page|
-      added_page = page
-    }
-    assert_equal @mech.get('http://localhost/tc_blank_form.html'), added_page
-  end
-  def test_history_order
-    @mech.max_history = 2
-    assert_equal(0, @mech.history.length)
-    @mech.get('http://localhost/form_test.html')
-    assert_equal(1, @mech.history.length)
-    @mech.get('http://localhost/empty_form.html')
-    assert_equal(2, @mech.history.length)
-    @mech.get('http://localhost/tc_checkboxes.html')
-    assert_equal(2, @mech.history.length)
-    assert_equal('http://localhost/empty_form.html', @mech.history[0].uri.to_s)
-    assert_equal('http://localhost/tc_checkboxes.html',
-                 @mech.history[1].uri.to_s)
-  end
-  def test_html_parser_equals
-    @mech.html_parser = {}
-    assert_raises(NoMethodError) {
-      @mech.get('http://localhost/?foo=~2').links
-    }
-  end
-  def test_idle_timeout_equals
-    @mech.idle_timeout = 5
-    assert_equal 5, @mech.idle_timeout
-  end
-  def test_keep_alive_equals
-    assert @mech.keep_alive
-    @mech.keep_alive = false
-    refute @mech.keep_alive
-  end
-  def test_keep_alive_time
-    assert_equal 0, @mech.keep_alive_time
-    @mech.keep_alive_time = 1
-    assert_equal 1, @mech.keep_alive_time
-  end
-  def test_log
-    assert_nil @mech.log
-  end
-  def test_log_equals
-    @mech.log = Logger.new $stderr
-    refute_nil @mech.log
-    assert_nil Mechanize.log
-  end
-  def test_max_file_buffer_equals
-    @mech.max_file_buffer = 1024
-    assert_equal 1024, @mech.agent.max_file_buffer
-  end
-  def test_max_history_equals
-    @mech.max_history = 10
-    0.upto(10) do |i|
-      assert_equal(i, @mech.history.size)
-      @mech.get("http://localhost/")
-    end
-    0.upto(10) do |i|
-      assert_equal(10, @mech.history.size)
-      @mech.get("http://localhost/")
-    end
-  end
-  def test_open_timeout_equals
-    @mech.open_timeout = 5
-    assert_equal 5, @mech.open_timeout
-  end
-  def test_parse_download
-    @mech.pluggable_parser['application/octet-stream'] = Mechanize::Download
-    response = Net::HTTPOK.allocate
-    response.instance_variable_set(:@header,
-                                   'content-type' =>
-                                     ['application/octet-stream'])
-    download = @mech.parse @uri, response, StringIO.new('raw')
-    assert_kind_of Mechanize::Download, download
-    assert_kind_of StringIO, download.content
-  end
-  def test_parse_html
-    response = Net::HTTPOK.allocate
-    response.instance_variable_set :@header, 'content-type' => ['text/html']
-    page = @mech.parse URI('http://example/'), response, ''
-    assert_kind_of Mechanize::Page, page
-  end
-  def test_post
-    @mech.post "http://example", 'gender' => 'female'
-    assert_equal "gender=female", requests.first.body
-  end
-  def test_post_basic_auth
-    requests = []
-    @mech.pre_connect_hooks << proc { |agent, request|
-      requests << request.class
-    }
-    @mech.basic_auth('user', 'pass')
-    page = @mech.post("http://localhost/basic_auth")
-    assert_equal('You are authenticated', page.body)
-    assert_equal(2, requests.length)
-    r1 = requests[0]
-    r2 = requests[1]
-    assert_equal(r1, r2)
-  end
-  def test_post_entity
-    @mech.post "http://localhost/form_post", 'json' => '["&quot;"]'
-    assert_equal "json=%5B%22%22%22%5D", requests.first.body
-  end
-  def test_post_multiple_values
-    @mech.post "http://localhost/form_post",
-                      [%w[gender female], %w[gender male]]
-    assert_equal "gender=female&gender=male", requests.first.body
-  end
-  def test_post_multipart
-    page = @mech.post('http://localhost/file_upload', {
-      :name       => 'Some file',
-      :userfile1  => File.open(__FILE__)
-    })
-    name = File.basename __FILE__
-    assert_match(
-      "Content-Disposition: form-data; name=\"userfile1\"; filename=\"#{name}\"",
-      page.body
-    )
-    assert page.body.length > File.read(__FILE__).length
-  end
-  def test_post_redirect
-    page = @mech.post('http://localhost/redirect')
-    assert_equal(page.uri.to_s, 'http://localhost/verb')
-    assert_equal 'GET', page.header['X-Request-Method']
-  end
-  def test_put
-    page = @mech.put('http://localhost/verb', 'foo')
-    assert_equal 1, @mech.history.length
-    assert_equal 'PUT', page.header['X-Request-Method']
-  end
-  def test_put_redirect
-    page = @mech.put('http://localhost/redirect', 'foo')
-    assert_equal(page.uri.to_s, 'http://localhost/verb')
-    assert_equal 'GET', page.header['X-Request-Method']
-  end
-  def test_read_timeout_equals
-    @mech.read_timeout = 5
-    assert_equal 5, @mech.read_timeout
-  end
-  def test_retry_change_requests_equals
-    refute @mech.retry_change_requests
-    @mech.retry_change_requests = true
-    assert @mech.retry_change_requests
-  end
-  def test_set_proxy
-    http = @mech.agent.http
-    @mech.set_proxy 'localhost', 8080, 'user', 'pass'
-    assert_equal 'localhost', @mech.proxy_addr
-    assert_equal 8080,        @mech.proxy_port
-    assert_equal 'user',      @mech.proxy_user
-    assert_equal 'pass',      @mech.proxy_pass
-    refute_same http, @mech.agent.http
-  end
-  def test_submit_bad_form_method
-    page = @mech.get("http://localhost/bad_form_test.html")
-    assert_raises ArgumentError do
-      @mech.submit(page.forms.first)
-    end
-  end
-  def test_submit_check_one
-    page = @mech.get('http://localhost/tc_checkboxes.html')
-    form = page.forms.first
-    form.checkboxes_with(:name => 'green')[1].check
-    page = @mech.submit(form)
-    assert_equal(1, page.links.length)
-    assert_equal('green:on', page.links.first.text)
-  end
-  def test_submit_check_two
-    page = @mech.get('http://localhost/tc_checkboxes.html')
-    form = page.forms.first
-    form.checkboxes_with(:name => 'green')[0].check
-    form.checkboxes_with(:name => 'green')[1].check
-    page = @mech.submit(form)
-    assert_equal(2, page.links.length)
-    assert_equal('green:on', page.links[0].text)
-    assert_equal('green:on', page.links[1].text)
-  end
-  def test_submit_enctype
-    page = @mech.get("http://localhost/file_upload.html")
-    assert_equal('multipart/form-data', page.forms[0].enctype)
-    form = page.forms.first
-    form.file_uploads.first.file_name = __FILE__
-    form.file_uploads.first.mime_type = "text/plain"
-    form.file_uploads.first.file_data = "Hello World\n\n"
-    page = @mech.submit(form)
-    basename = File.basename __FILE__
-    assert_match(
-      "Content-Disposition: form-data; name=\"userfile1\"; filename=\"#{basename}\"",
-      page.body
-    )
-    assert_match(
-      "Content-Disposition: form-data; name=\"name\"",
-      page.body
-    )
-    assert_match('Content-Type: text/plain', page.body)
-    assert_match('Hello World', page.body)
-    assert_match('foo[aaron]', page.body)
-  end
-  def test_submit_file_data
-    page = @mech.get("http://localhost/file_upload.html")
-    assert_equal('multipart/form-data', page.forms[1].enctype)
-    form = page.forms[1]
-    form.file_uploads.first.file_name = __FILE__
-    form.file_uploads.first.file_data = File.read __FILE__
-    page = @mech.submit(form)
-    contents = File.read __FILE__
-    basename = File.basename __FILE__
-    assert_match(
-      "Content-Disposition: form-data; name=\"green[eggs]\"; filename=\"#{basename}\"",
-      page.body
-    )
-    assert_match(contents, page.body)
-  end
-  def test_submit_file_name
-    page = @mech.get("http://localhost/file_upload.html")
-    assert_equal('multipart/form-data', page.forms[1].enctype)
-    form = page.forms[1]
-    form.file_uploads.first.file_name = __FILE__
-    page = @mech.submit(form)
-    contents = File.read __FILE__
-    basename = File.basename __FILE__
-    assert_match(
-      "Content-Disposition: form-data; name=\"green[eggs]\"; filename=\"#{basename}\"",
-      page.body
-    )
-    assert_match(contents, page.body)
-  end
-  def test_submit_get
-    form = node 'form', 'method' => 'GET', 'action' => '/?a=b'
-    form = Mechanize::Form.new form, @mech, fake_page
-    @mech.submit form
-    assert_equal '/', requests.first.path
-  end
-  def test_submit_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_multipart
-    page = @mech.get("http://localhost/file_upload.html")
-    assert_equal('multipart/form-data', page.forms[1].enctype)
-    form = page.forms[1]
-    form.file_uploads.first.file_name = __FILE__
-    form.file_uploads.first.mime_type = "text/plain"
-    form.file_uploads.first.file_data = "Hello World\n\n"
-    page = @mech.submit(form)
-    basename = File.basename __FILE__
-    assert_match(
-      "Content-Disposition: form-data; name=\"green[eggs]\"; filename=\"#{basename}\"",
-      page.body
-    )
-  end
-  def test_submit_no_file
-    page = @mech.get("http://localhost/file_upload.html")
-    form = page.forms.first
-    form.field_with(:name => 'name').value = 'Aaron'
-    @page = @mech.submit(form)
-    assert_match('Aaron', @page.body)
-    assert_match(
-      "Content-Disposition: form-data; name=\"userfile1\"; filename=\"\"",
-      @page.body
-    )
-  end
-  def test_submit_post
-    form = node 'form', 'method' => 'POST', 'action' => '/?a=b'
-    form = Mechanize::Form.new form, @mech, fake_page
-    @mech.submit form
-    assert_equal '/?a=b', requests.first.path
-  end
-  def test_submit_post_pound
-    form = node 'form', 'method' => 'POST', 'action' => '/#1'
-    form = Mechanize::Form.new form, @mech, fake_page
-    @mech.submit form
-    assert_equal '/', requests.first.path
-  end
-  def test_submit_too_many_radiobuttons
-    page = @mech.get("http://localhost/form_test.html")
-    form = page.form_with(:name => 'post_form1')
-    form.radiobuttons.each { |r| r.checked = true }
-    assert_raises Mechanize::Error do
-      @mech.submit(form)
-    end
-  end
-  def test_transact
-    @mech.get("http://localhost/frame_test.html")
-    assert_equal(1, @mech.history.length)
-    @mech.transact { |a|
-      5.times {
-        @mech.get("http://localhost/frame_test.html")
-      }
-      assert_equal(6, @mech.history.length)
-    }
-    assert_equal(1, @mech.history.length)
-  end
-  def test_user_agent_alias_equals_unknown
-    assert_raises ArgumentError do
-      @mech.user_agent_alias = "Aaron's Browser"
-    end
-  end
-  def test_verify_mode
-    assert_equal OpenSSL::SSL::VERIFY_PEER, @mech.verify_mode
-    @mech.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    assert_equal OpenSSL::SSL::VERIFY_NONE, @mech.verify_mode
-  end
-  def test_visited_eh
-    @mech.get("http://localhost/content_type_test?ct=application/pdf")
-    assert \
-      @mech.visited?("http://localhost/content_type_test?ct=application/pdf")
-    assert \
-      !@mech.visited?("http://localhost/content_type_test")
-    assert \
-      !@mech.visited?("http://localhost/content_type_test?ct=text/html")
-  end
-  def test_visited_eh_link
-    @mech.get("http://example/index.html")
-    page = page URI 'http://example'
-    link = node 'a', 'href' => '/index.html'
-    link = Mechanize::Page::Link.new link, page, @mech
-    assert @mech.visited? link
-  end
-  def test_visited_eh_redirect
-    @mech.get("http://localhost/response_code?code=302")
-    assert_equal("http://localhost/index.html", @mech.current_page.uri.to_s)
-    assert @mech.visited?('http://localhost/response_code?code=302')
-  end
-  def assert_header(page, header)
-    headers = {}
-    page.body.split(/[\r\n]+/).each do |page_header|
-      headers.[]=(*page_header.chomp.split(/\|/))
-    end
-    header.each do |key, value|
-      assert(headers.has_key?(key))
-      assert_equal(value, headers[key])
-    end
-  end
-end