mechanize 2.0.1 → 2.1.pre.1

data/test/test_mechanize_form_select_list.rb

@@ -0,0 +1,76 @@
+require 'mechanize/test_case'
+
+class TestMechanizeFormSelectList < Mechanize::TestCase
+
+  def setup
+    super
+
+    page = html_page <<-BODY
+<form name="form1" method="post" action="/form_post">
+  <select name="select">
+    <option value="1">Option 1</option>
+    <option value="2" selected>Option 2</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>
+</form>
+    BODY
+
+    form = page.forms.first
+    @select = form.fields.first
+  end
+
+  def test_option_with
+    option = @select.option_with :value => '1'
+
+    assert_equal '1', option.value
+  end
+
+  def test_options_with
+    options = @select.options_with :value => /[12]/
+
+    assert_equal 2, options.length
+  end
+
+  def test_query_value
+    assert_equal [%w[select 2]], @select.query_value
+
+    @select.select_all
+
+    assert_equal [%w[select 6]], @select.query_value
+  end
+
+  def test_select_all
+    @select.select_all
+
+    assert_equal "6", @select.value
+  end
+
+  def test_select_none
+    @select.select_none
+
+    assert_equal "1", @select.value
+  end
+
+  def test_selected_options
+    assert_equal [@select.options[1]], @select.selected_options
+
+    @select.options.last.click
+
+    assert_equal [@select.options.last], @select.selected_options
+  end
+
+  def test_value
+    assert_equal "2", @select.value
+  end
+
+  def test_value_equals
+    @select.value = %w[a 1 2]
+
+    assert_equal "a", @select.value
+  end
+
+end
+

data/test/test_mechanize_form_textarea.rb

@@ -1,9 +1,10 @@
-require "helper"
+require 'mechanize/test_case'
 
-class TestMechanizeFormTextarea < MiniTest::Unit::TestCase
+class TestMechanizeFormTextarea < Mechanize::TestCase
   def setup
-    @agent = Mechanize.new
-    @page  = @agent.get("http://localhost/tc_textarea.html")
+    super
+
+    @page  = @mech.get("http://localhost/tc_textarea.html")
   end
 
   def test_empty_text_area
@@ -11,7 +12,7 @@ class TestMechanizeFormTextarea < MiniTest::Unit::TestCase
     assert_equal('', form.field_with(:name => 'text1').value)
     form.text1 = 'Hello World'
     assert_equal('Hello World', form.field_with(:name => 'text1').value)
-    page = @agent.submit(form)
+    page = @mech.submit(form)
     assert_equal(1, page.links.length)
     assert_equal('text1:Hello World', page.links[0].text)
   end
@@ -19,7 +20,7 @@ class TestMechanizeFormTextarea < MiniTest::Unit::TestCase
   def test_non_empty_textfield
     form = @page.forms_with(:name => 'form2').first
     assert_equal('sample text', form.field_with(:name => 'text1').value)
-    page = @agent.submit(form)
+    page = @mech.submit(form)
     assert_equal(1, page.links.length)
     assert_equal('text1:sample text', page.links[0].text)
   end
@@ -36,7 +37,7 @@ class TestMechanizeFormTextarea < MiniTest::Unit::TestCase
     assert_equal('Hello World', form.fields_with(:name => 'text1')[0].value)
     assert_equal('sample text', form.fields_with(:name => 'text1')[1].value)
 
-    page = @agent.submit(form)
+    page = @mech.submit(form)
 
     assert_equal(2, page.links.length)
 

data/test/{test_headers.rb → test_mechanize_headers.rb}

@@ -1,7 +1,9 @@
-require "helper"
+require 'mechanize/test_case'
 
-class TestHeaders < MiniTest::Unit::TestCase
+class TestMechanizeHeaders < Mechanize::TestCase
   def setup
+    super
+
     @headers = Mechanize::Headers.new
     @headers['content-type'] = 'text/html'
     @headers['Content-encoding'] = 'gzip'

data/test/test_mechanize_history.rb

@@ -0,0 +1,103 @@
+require 'mechanize/test_case'
+
+class TestMechanizeHistory < Mechanize::TestCase
+
+  def setup
+    super
+
+    @uri = URI 'http://example/'
+    @uri2 = @uri + '/a'
+    @history = Mechanize::History.new
+  end
+
+  def test_initialize
+    assert_empty @history
+  end
+
+  def test_clear
+    @history.push :page, @uri
+
+    @history.clear
+
+    assert_empty @history
+  end
+
+  def test_pop
+    assert_nil @history.pop
+
+    @history.push :page1, @uri
+    @history.push :page2, @uri2
+
+    assert_equal :page2, @history.pop
+    refute_empty @history
+  end
+
+  def test_push
+    p1 = page @uri
+
+    obj = @history.push p1
+
+    assert_same @history, obj
+    assert_equal 1, @history.length
+
+    p2 = page @uri2
+
+    @history.push p2
+
+    assert_equal 2, @history.length
+  end
+
+  def test_push_max_size
+    @history = Mechanize::History.new 2
+
+    @history.push :page1, @uri
+
+    assert_equal 1, @history.length
+
+    @history.push :page2, @uri
+
+    assert_equal 2, @history.length
+
+    @history.push :page3, @uri
+
+    assert_equal 2, @history.length
+  end
+
+  def test_push_uri
+    obj = @history.push :page, @uri
+
+    assert_same @history, obj
+    assert_equal 1, @history.length
+
+    @history.push :page2, @uri
+
+    assert_equal 2, @history.length
+  end
+
+  def test_shift
+    assert_nil @history.shift
+
+    @history.push :page1, @uri
+    @history.push :page2, @uri2
+
+    page = @history.shift
+
+    assert_equal :page1, page
+    refute_empty @history
+
+    @history.shift
+
+    assert_empty @history
+  end
+
+  def test_visited_eh
+    refute @history.visited? @uri
+
+    @history.push page @uri
+
+    assert @history.visited? URI('http://example')
+    assert @history.visited? URI('http://example/')
+  end
+
+end
+

data/test/test_mechanize_http_agent.rb

@@ -1,10 +1,12 @@
 # coding: utf-8
-require 'helper'
 
-class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
+require 'mechanize/test_case'
+
+class TestMechanizeHttpAgent < Mechanize::TestCase
 
   def setup
-    @mech = Mechanize.new
+    super
+
     @agent = @mech.agent
 
     @uri = URI.parse 'http://example/'
@@ -21,6 +23,14 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
                end
   end
 
+  def auth_realm uri, scheme, type
+    base_uri = uri + '/'
+    realm = Mechanize::HTTP::AuthRealm.new scheme, base_uri, 'r'
+    @agent.authenticate_methods[base_uri][type] << realm
+
+    realm
+  end
+
   def test_connection_for_file
     uri = URI.parse 'file:///nonexistent'
     conn = @agent.connection_for uri
@@ -34,6 +44,20 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
     assert_equal @agent.http, conn
   end
 
+  def test_disable_keep_alive
+    @agent.disable_keep_alive @req
+
+    refute @req['connection']
+  end
+
+  def test_disable_keep_alive_no
+    @agent.keep_alive = false
+
+    @agent.disable_keep_alive @req
+
+    assert_equal 'close', @req['connection']
+  end
+
   def test_enable_gzip
     @agent.enable_gzip @req
 
@@ -48,6 +72,22 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
     assert_equal 'identity', @req['accept-encoding']
   end
 
+  def test_fetch_hooks
+    @agent.pre_connect_hooks << proc do |agent, request|
+      assert_equal '/index.html', request.path
+      assert_equal @agent, agent
+    end
+
+    @agent.post_connect_hooks << proc do |agent, uri, response, body|
+      assert_equal @agent, agent
+      assert_equal URI('http://example/index.html'), uri
+      assert_equal '200', response.code
+      assert_kind_of String, body
+    end
+
+    @agent.fetch URI 'http://example/index.html'
+  end
+
   def test_fetch_file_plus
     Tempfile.open '++plus++' do |io|
       content = 'plusses +++'
@@ -93,6 +133,14 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
     assert response
   end
 
+  def test_fetch_server_error
+    e = assert_raises Mechanize::ResponseCodeError do
+      @mech.get 'http://localhost/response_code?code=500'
+    end
+
+    assert_equal '500', e.response_code
+  end
+
   def test_get_robots
     robotstxt = @agent.get_robots 'http://localhost/robots.txt'
     refute_equal '', robotstxt
@@ -123,6 +171,13 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
     assert_equal '/', request.path
   end
 
+  def test_idle_timeout_equals
+    @agent.set_http
+    @agent.idle_timeout = 1
+
+    assert_equal 1, @agent.http.idle_timeout
+  end
+
   def test_post_connect
     @agent.post_connect_hooks << proc { |agent, uri, response, body|
       assert_equal @agent, agent
@@ -131,9 +186,13 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
       throw :called
     }
 
+    io = StringIO.new 'body'
+
     assert_throws :called do
-      @agent.post_connect @uri, @res, 'body'
+      @agent.post_connect @uri, @res, io
     end
+
+    assert_equal 0, io.pos
   end
 
   def test_pre_connect
@@ -251,6 +310,49 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
     assert_equal 'unknown header symbol content_length', e.message
   end
 
+  def test_request_auth_none
+    @agent.request_auth @req, @uri
+
+    assert_nil @req['Authorization']
+  end
+
+  def test_request_auth_basic
+    @agent.user = 'user'
+    @agent.password = 'password'
+
+    auth_realm @uri, 'Basic', :basic
+
+    @agent.request_auth @req, @uri
+
+    assert_match %r%^Basic %, @req['Authorization']
+  end
+
+  def test_request_auth_digest
+    @agent.user = 'user'
+    @agent.password = 'password'
+
+    realm = auth_realm @uri, 'Digest', :digest
+    @agent.digest_challenges[realm] = 'Digest realm=r, qop="auth"'
+
+    @agent.request_auth @req, @uri
+
+    assert_match %r%^Digest %, @req['Authorization']
+    assert_match %r%qop=auth%, @req['Authorization']
+  end
+
+  def test_request_auth_iis_digest
+    @agent.user = 'user'
+    @agent.password = 'password'
+
+    realm = auth_realm @uri, 'Digest', :digest
+    @agent.digest_challenges[realm] = 'Digest realm=r, qop="auth"'
+
+    @agent.request_auth @req, @uri
+
+    assert_match %r%^Digest %, @req['Authorization']
+    assert_match %r%qop=auth%, @req['Authorization']
+  end
+
   def test_request_referer
     referer = URI.parse 'http://old.example'
 
@@ -285,6 +387,15 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
     assert_nil @req['referer']
   end
 
+  def test_request_referer_https_upgrade
+    uri = URI.parse 'https://example'
+    referer = URI.parse 'http://old.example'
+
+    @agent.request_referer @req, uri, referer
+
+    assert_equal 'http://old.example', @req['referer']
+  end
+
   def test_request_referer_none
     @agent.request_referer @req, @uri, nil
 
@@ -347,13 +458,95 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
     assert_nil params
   end
 
+  def test_response_authenticate
+    @res.instance_variable_set :@header, 'www-authenticate' => ['Basic realm=r']
+    @agent.user = 'user'
+    @agent.password = 'password'
+
+    @agent.response_authenticate @res, nil, @uri, @req, {}, nil, nil
+
+    base_uri = @uri + '/'
+    realm = Mechanize::HTTP::AuthRealm.new 'Basic', base_uri, 'r'
+    assert_equal [realm], @agent.authenticate_methods[base_uri][:basic]
+  end
+
+  def test_response_authenticate_digest
+    @res.instance_variable_set(:@header,
+                               'www-authenticate' => ['Digest realm=r'])
+    @agent.user = 'user'
+    @agent.password = 'password'
+
+    @agent.response_authenticate @res, nil, @uri, @req, {}, nil, nil
+
+    base_uri = @uri + '/'
+    realm = Mechanize::HTTP::AuthRealm.new 'Digest', base_uri, 'r'
+    assert_equal [realm], @agent.authenticate_methods[base_uri][:digest]
+
+    challenge = Mechanize::HTTP::AuthChallenge.new 'Digest', 'realm' => 'r'
+    assert_equal challenge, @agent.digest_challenges[realm]
+  end
+
+  def test_response_authenticate_digest_iis
+    @res.instance_variable_set(:@header,
+                               'www-authenticate' => ['Digest realm=r'],
+                               'server'           => ['Microsoft-IIS'])
+    @agent.user = 'user'
+    @agent.password = 'password'
+
+    @agent.response_authenticate @res, nil, @uri, @req, {}, nil, nil
+
+    base_uri = @uri + '/'
+    realm = Mechanize::HTTP::AuthRealm.new 'Digest', base_uri, 'r'
+    assert_equal [realm], @agent.authenticate_methods[base_uri][:iis_digest]
+  end
+
+  def test_response_authenticate_multiple
+    @res.instance_variable_set(:@header,
+                               'www-authenticate' =>
+                                 ['Basic realm=r, Digest realm=r'])
+    @agent.user = 'user'
+    @agent.password = 'password'
+
+    @agent.response_authenticate @res, nil, @uri, @req, {}, nil, nil
+
+    base_uri = @uri + '/'
+    realm = Mechanize::HTTP::AuthRealm.new 'Digest', base_uri, 'r'
+    assert_equal [realm], @agent.authenticate_methods[base_uri][:digest]
+
+    assert_empty @agent.authenticate_methods[base_uri][:basic]
+  end
+
+  def test_response_authenticate_ntlm
+    @uri += '/ntlm'
+    @res.instance_variable_set(:@header,
+                               'www-authenticate' => ['NTLM'])
+    @agent.user = 'user'
+    @agent.password = 'password'
+
+    page = @agent.response_authenticate @res, nil, @uri, @req, {}, nil, nil
+
+    assert_equal 'ok', page.body # lame test
+  end
+
+  def test_response_authenticate_unknown
+    @agent.user = 'user'
+    @agent.password = 'password'
+    page = Mechanize::File.new nil, nil, nil, 401
+    @res.instance_variable_set(:@header,
+                               'www-authenticate' => ['Unknown realm=r'])
+
+    assert_raises Mechanize::UnauthorizedError do
+      @agent.response_authenticate @res, page, @uri, @req, nil, nil, nil
+    end
+  end
+
   def test_response_content_encoding_7_bit
     def @res.content_length() 4 end
     @res.instance_variable_set :@header, 'content-encoding' => %w[7bit]
 
     body = @agent.response_content_encoding @res, StringIO.new('part')
 
-    assert_equal 'part', body
+    assert_equal 'part', body.read
   end
 
   def test_response_content_encoding_deflate
@@ -363,7 +556,7 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
 
     body = @agent.response_content_encoding @res, body_io
 
-    assert_equal 'part', body
+    assert_equal 'part', body.read
   end
 
   def test_response_content_encoding_deflate_chunked
@@ -373,7 +566,7 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
 
     body = @agent.response_content_encoding @res, body_io
 
-    assert_equal 'part', body
+    assert_equal 'part', body.read
   end
 
   # IIS/6.0 ASP.NET/2.0.50727 does not wrap deflate with zlib, WTF?
@@ -383,7 +576,7 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
 
     body = @agent.response_content_encoding @res, StringIO.new("+H,*\001\000")
 
-    assert_equal 'part', body
+    assert_equal 'part', body.read
   end
 
   def test_response_content_encoding_gzip
@@ -394,7 +587,7 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
 
     body = @agent.response_content_encoding @res, body_io
 
-    assert_equal 'part', body
+    assert_equal 'part', body.read
   end
 
   def test_response_content_encoding_gzip_chunked
@@ -405,7 +598,7 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
 
     body = @agent.response_content_encoding @res, body_io
 
-    assert_equal 'part', body
+    assert_equal 'part', body.read
   end
 
   def test_response_content_encoding_none
@@ -414,7 +607,7 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
 
     body = @agent.response_content_encoding @res, StringIO.new('part')
 
-    assert_equal 'part', body
+    assert_equal 'part', body.read
   end
 
   def test_response_content_encoding_x_gzip
@@ -425,7 +618,7 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
 
     body = @agent.response_content_encoding @res, body_io
 
-    assert_equal 'part', body
+    assert_equal 'part', body.read
   end
 
   def test_response_content_encoding_unknown
@@ -440,6 +633,99 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
     assert_equal 'Unsupported Content-Encoding: unknown', e.message
   end
 
+  def test_get_meta_refresh_header_follow_self
+    @agent.follow_meta_refresh = true
+    @agent.follow_meta_refresh_self = true
+
+    page = Mechanize::Page.new(@uri, {'content-type' => 'text/html'}, '',
+                               200, @mech)
+    @res.instance_variable_set :@header, 'refresh' => ['0']
+
+    refresh = @agent.get_meta_refresh @res, @uri, page
+
+    assert_equal [0.0, URI('http://example/')], refresh
+  end
+
+  def test_get_meta_refresh_header_no_follow
+    page = Mechanize::Page.new(@uri, {'content-type' => 'text/html'}, '',
+                               200, @mech)
+    @res.instance_variable_set :@header, 'refresh' => ['0']
+
+    refresh = @agent.get_meta_refresh @res, @uri, page
+
+    assert_nil refresh
+  end
+
+  def test_get_meta_refresh_header_no_follow_self
+    @agent.follow_meta_refresh = true
+
+    page = Mechanize::Page.new(@uri, {'content-type' => 'text/html'}, '',
+                               200, @mech)
+    @res.instance_variable_set :@header, 'refresh' => ['0']
+
+    refresh = @agent.get_meta_refresh @res, @uri, page
+
+    assert_nil refresh
+  end
+
+  def test_get_meta_refresh_meta_follow_self
+    @agent.follow_meta_refresh = true
+    @agent.follow_meta_refresh_self = true
+
+    body = <<-BODY
+<title></title>
+<meta http-equiv="refresh" content="0">
+    BODY
+
+    page = Mechanize::Page.new(@uri, {'content-type' => 'text/html'}, body,
+                               200, @mech)
+
+    refresh = @agent.get_meta_refresh @res, @uri, page
+
+    assert_equal [0, 'http://example/'], refresh
+  end
+
+  def test_get_meta_refresh_meta_no_follow
+    body = <<-BODY
+<title></title>
+<meta http-equiv="refresh" content="0">
+    BODY
+
+    page = Mechanize::Page.new(@uri, {'content-type' => 'text/html'}, body,
+                               200, @mech)
+
+    refresh = @agent.get_meta_refresh @res, @uri, page
+
+    assert_nil refresh
+  end
+
+  def test_get_meta_refresh_meta_no_follow_self
+    @agent.follow_meta_refresh = true
+
+    body = <<-BODY
+<title></title>
+<meta http-equiv="refresh" content="0">
+    BODY
+
+    page = Mechanize::Page.new(@uri, {'content-type' => 'text/html'}, body,
+                               200, @mech)
+
+    refresh = @agent.get_meta_refresh @res, @uri, page
+
+    assert_nil refresh
+  end
+
+  def test_hook_content_encoding_response
+    @mech.content_encoding_hooks << lambda{|agent, uri, response, response_body_io|
+      response['content-encoding'] = 'gzip' if response['content-encoding'] == 'agzip'}
+
+    @res.instance_variable_set :@header, 'content-encoding' => %w[agzip]
+    body_io = StringIO.new 'part'
+    @agent.hook_content_encoding @res, @uri, body_io
+
+    assert_equal 'gzip', @res['content-encoding']
+  end
+
   def test_response_cookies
     uri = URI.parse 'http://host.example.com'
     cookie_str = 'a=b domain=.example.com'
@@ -454,6 +740,21 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
                  @agent.cookie_jar.cookies(uri).map { |c| c.to_s }
   end
 
+  def test_response_cookies_many
+    uri = URI.parse 'http://host.example.com'
+    cookie1 = 'a=b domain=.example.com'
+    cookie2 = 'c=d domain=.example.com'
+    @res.instance_variable_set(:@header,
+                               'set-cookie' => [cookie1, cookie2],
+                               'content-type' => %w[text/html])
+    page = Mechanize::Page.new uri, @res, '', 200, @mech
+
+    @agent.response_cookies @res, uri, page
+
+    assert_equal ['a=b domain=.example.com', 'c=d domain=.example.com'],
+                 @agent.cookie_jar.cookies(uri).map { |c| c.to_s }
+  end
+
   def test_response_cookies_meta
     uri = URI.parse 'http://host.example.com'
     cookie_str = 'a=b domain=.example.com'
@@ -486,12 +787,33 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
                                200, @mech)
 
     @agent.follow_meta_refresh = true
+    @agent.follow_meta_refresh_self = true
 
     page = @agent.response_follow_meta_refresh @res, uri, page, 0
 
     assert_equal uri, page.uri
   end
 
+  def test_response_follow_meta_refresh_limit
+    uri = URI.parse 'http://example/#id+1'
+
+    body = <<-BODY
+<title></title>
+<meta http-equiv="refresh" content="0">
+    BODY
+
+    page = Mechanize::Page.new(uri, {'content-type' => 'text/html'}, body,
+                               200, @mech)
+
+    @agent.follow_meta_refresh = true
+    @agent.follow_meta_refresh_self = true
+
+    assert_raises Mechanize::RedirectLimitReachedError do
+      @agent.response_follow_meta_refresh(@res, uri, page,
+                                          @agent.redirection_limit)
+    end
+  end
+
   def test_response_read
     def @res.read_body() yield 'part' end
     def @res.content_length() 4 end
@@ -504,6 +826,28 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
     assert_equal Encoding::BINARY, body.encoding if body.respond_to? :encoding
   end
 
+  def test_response_read_large
+    def @res.read_body() yield 'a' * 10241 end
+    def @res.content_length() 10241 end
+
+    io = @agent.response_read @res, @req
+
+    assert_kind_of Tempfile, io
+    assert_equal 10241, io.stat.size
+  end
+
+  def test_response_read_large_chunked
+    def @res.read_body
+      11.times do yield 'a' * 1024 end
+    end
+    def @res.content_length() end
+
+    io = @agent.response_read @res, @req
+
+    assert_kind_of Tempfile, io
+    assert_equal 11264, io.stat.size
+  end
+
   def test_response_read_content_length_head
     req = Net::HTTP::Head.new '/'
 
@@ -589,6 +933,7 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
   def test_response_read_unknown_code
     res = Net::HTTPUnknownResponse.allocate
     res.instance_variable_set :@code, 9999
+    res.instance_variable_set :@header, {}
     def res.read_body() yield 'part' end
 
     e = assert_raises Mechanize::ResponseCodeError do
@@ -598,6 +943,63 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
     assert_equal res, e.page
   end
 
+  def test_response_redirect
+    @agent.redirect_ok = true
+    referer = page 'http://example/referer'
+
+    page = fake_page
+    page = @agent.response_redirect({ 'Location' => '/index.html' }, :get,
+                                    page, 0, referer)
+
+    assert_equal URI('http://fake.example/index.html'), page.uri
+
+    assert_equal 'http://example/referer', requests.first['Referer']
+  end
+
+  def test_response_redirect_limit
+    @agent.redirect_ok = true
+    referer = page 'http://example/referer'
+
+    assert_raises Mechanize::RedirectLimitReachedError do
+      @agent.response_redirect({ 'Location' => '/index.html' }, :get,
+                               fake_page, @agent.redirection_limit, referer)
+    end
+  end
+
+  def test_response_redirect_not_ok
+    @agent.redirect_ok = false
+
+    page = fake_page
+    page = @agent.response_redirect({ 'Location' => '/other' }, :get, page, 0,
+                                    page)
+
+    assert_equal URI('http://fake.example'), page.uri
+  end
+
+  def test_response_redirect_permanent
+    @agent.redirect_ok = :permanent
+
+    response = Net::HTTPMovedPermanently.allocate
+    response.instance_variable_set :@header, { 'location' => %w[/index.html] }
+
+    page = fake_page
+    page = @agent.response_redirect response, :get, page, 0, page
+
+    assert_equal URI('http://fake.example/index.html'), page.uri
+  end
+
+  def test_response_redirect_permanent_temporary
+    @agent.redirect_ok = :permanent
+
+    response = Net::HTTPMovedTemporarily.allocate
+    response.instance_variable_set :@header, { 'location' => %w[/index.html] }
+
+    page = fake_page
+    page = @agent.response_redirect response, :get, page, 0, page
+
+    assert_equal URI('http://fake.example/'), page.uri
+  end
+
   def test_response_parse
     body = '<title>hi</title>'
     @res.instance_variable_set :@header, 'content-type' => %w[text/html]
@@ -684,13 +1086,119 @@ class TestMechanizeHttpAgent < MiniTest::Unit::TestCase
     assert_equal 'UTF-8', page.encoding
   end
 
+  def test_robots_allowed_eh
+    allowed    = URI 'http://localhost/index.html'
+    disallowed = URI 'http://localhost/norobots.html'
+
+    assert @agent.robots_allowed? allowed
+    refute @agent.robots_allowed? disallowed
+
+    refute @agent.robots_disallowed? allowed
+    assert @agent.robots_disallowed? disallowed
+  end
+
+  def test_robots_allowed_eh_noindex
+    @agent.robots = true
+
+    noindex = URI 'http://localhost/noindex.html'
+
+    assert @agent.robots_allowed? noindex
+
+    assert_raises Mechanize::RobotsDisallowedError do
+      @agent.fetch noindex
+    end
+  end
+
+  def test_set_http
+    @agent.set_http
+
+    assert_equal 'mechanize', @agent.http.name
+    refute @agent.http.retry_change_requests
+  end
+
+  def test_set_http_idle_timeout
+    @agent.idle_timeout = 1
+    @agent.set_http
+
+    assert_equal 'mechanize', @agent.http.name
+    assert_equal 1, @agent.http.idle_timeout
+  end
+
+  def test_set_http_ssl
+    in_tmpdir do
+      store = OpenSSL::X509::Store.new
+      @agent.cert = ssl_certificate
+      @agent.key  = ssl_private_key
+      @agent.cert_store = store
+      @agent.ca_file = '.'
+      @agent.verify_callback = proc { |ok, context| }
+
+      @agent.set_http
+
+      http = @agent.http
+
+      assert_equal ssl_certificate,           http.certificate
+      assert_equal ssl_private_key,           http.private_key
+      assert_equal store,                     http.cert_store
+      assert_equal '.',                       http.ca_file
+      assert_equal OpenSSL::SSL::VERIFY_PEER, http.verify_mode
+      assert http.verify_callback
+    end
+  end
+
+  def test_set_http_ssl_verify_none
+    in_tmpdir do
+      @agent.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      @agent.set_http
+
+      http = @agent.http
+
+      assert_equal OpenSSL::SSL::VERIFY_NONE, http.verify_mode
+    end
+  end
+
+  def test_set_http_retry_change_request
+    @agent.retry_change_requests = true
+    @agent.set_http
+
+    assert_equal 'mechanize', @agent.http.name
+    assert @agent.http.retry_change_requests
+  end
+
   def test_set_proxy
-    @agent.set_proxy('www.example.com', 9001, 'joe', 'lol')
+    @agent.set_proxy 'www.example.com', 9001, 'joe', 'lol'
+
+    assert_equal @agent.proxy_uri.host,     'www.example.com'
+    assert_equal @agent.proxy_uri.port,     9001
+    assert_equal @agent.proxy_uri.user,     'joe'
+    assert_equal @agent.proxy_uri.password, 'lol'
+  end
+
+  def test_set_proxy_port_string
+    @agent.set_proxy 'www.example.com', '9001', 'joe', 'lol'
+
+    assert_equal @agent.proxy_uri.host,     'www.example.com'
+    assert_equal @agent.proxy_uri.port,     9001
+    assert_equal @agent.proxy_uri.user,     'joe'
+    assert_equal @agent.proxy_uri.password, 'lol'
+  end
+
+  def test_set_proxy_service_name
+    @agent.set_proxy 'www.example.com', 'http', 'joe', 'lol'
+
+    assert_equal @agent.proxy_uri.host,     'www.example.com'
+    assert_equal @agent.proxy_uri.port,     80
+    assert_equal @agent.proxy_uri.user,     'joe'
+    assert_equal @agent.proxy_uri.password, 'lol'
+  end
+
+  def test_set_proxy_service_name_bad
+    e = assert_raises ArgumentError do
+      @agent.set_proxy 'www.example.com', 'nonexistent service', 'joe', 'lol'
+    end
 
-    assert_equal(@agent.proxy_uri.host,     'www.example.com')
-    assert_equal(@agent.proxy_uri.port,     9001)
-    assert_equal(@agent.proxy_uri.user,     'joe')
-    assert_equal(@agent.proxy_uri.password, 'lol')
+    assert_equal 'invalid value for port: "nonexistent service"', e.message
   end
 
 end