mechanize 1.0.1.beta.20110107104205 → 2.0.pre.1

data/test/test_authenticate.rb

@@ -20,9 +20,9 @@ class BasicAuthTest < Test::Unit::TestCase
 
   def test_no_duplicate_headers
     block_called = false
-    @agent.pre_connect_hooks << lambda { |params|
+    @agent.pre_connect_hooks << lambda { |_, request|
       block_called = true
-      params[:request].to_hash.each do |k,v|
+      request.to_hash.each do |k,v|
         assert_equal(1, v.length)
       end
     }
@@ -35,10 +35,10 @@ class BasicAuthTest < Test::Unit::TestCase
     class << @agent
       alias :old_fetch_page :fetch_page
       attr_accessor :requests
-      def fetch_page(args)
+      def fetch_page(uri, method, *args)
         @requests ||= []
-        x = old_fetch_page(args)
-        @requests << args[:verb]
+        x = old_fetch_page(uri, method, *args)
+        @requests << method
         x
       end
     end

data/test/test_errors.rb

@@ -7,9 +7,9 @@ class MechErrorsTest < Test::Unit::TestCase
 
   def test_bad_form_method
     page = @agent.get("http://localhost/bad_form_test.html")
-    assert_raise(RuntimeError) {
+    assert_raise ArgumentError do
       @agent.submit(page.forms.first)
-    }
+    end
   end
 
   def test_non_exist
@@ -24,21 +24,21 @@ class MechErrorsTest < Test::Unit::TestCase
     page = @agent.get("http://localhost/form_test.html")
     form = page.form_with(:name => 'post_form1')
     form.radiobuttons.each { |r| r.checked = true }
-    assert_raise(RuntimeError) {
+    assert_raise Mechanize::Error do
       @agent.submit(form)
-    }
+    end
   end
 
   def test_unknown_agent
-    assert_raise(RuntimeError) {
+    assert_raise ArgumentError do
       @agent.user_agent_alias = "Aaron's Browser"
-    }
+    end
   end
 
   def test_bad_url
-    assert_raise(RuntimeError) {
+    assert_raise ArgumentError do
       @agent.get('/foo.html')
-    }
+    end
   end
 
   def test_unsupported_scheme

data/test/test_follow_meta.rb

@@ -8,8 +8,8 @@ class FollowMetaTest < Test::Unit::TestCase
   def test_dont_follow_meta_in_body
     @agent.follow_meta_refresh = true
     requests = []
-    @agent.pre_connect_hooks << lambda { |params|
-      requests << params[:request]
+    @agent.pre_connect_hooks << lambda { |_, request|
+      requests << request
     }
 
     @agent.get('http://localhost/tc_meta_in_body.html')
@@ -25,8 +25,8 @@ class FollowMetaTest < Test::Unit::TestCase
   def test_meta_refresh_does_not_send_referer
     @agent.follow_meta_refresh = true
     requests = []
-    @agent.pre_connect_hooks << lambda { |params|
-      requests << params[:request]
+    @agent.pre_connect_hooks << lambda { |_, request|
+      requests << request
     }
 
     @agent.get('http://localhost/tc_follow_meta.html')

data/test/test_form_as_hash.rb

@@ -46,13 +46,13 @@ class TestFormHash < Test::Unit::TestCase
     form = @page.forms.first
 
     assert_not_nil(form)
-    assert_equal(false, form.has_field?('name'))
-    assert_equal(false, form.has_value?('Aaron'))
+    assert(!form.has_field?('name'))
+    assert(!form.has_value?('Aaron'))
     assert_equal(0, form.keys.length)
     assert_equal(0, form.values.length)
     form['name'] = 'Aaron'
-    assert_equal(true, form.has_field?('name'))
-    assert_equal(true, form.has_value?('Aaron'))
+    assert(form.has_field?('name'))
+    assert(form.has_value?('Aaron'))
     assert_equal(1, form.keys.length)
     assert_equal(['name'], form.keys)
     assert_equal(1, form.values.length)

data/test/test_forms.rb

@@ -271,7 +271,7 @@ class FormsMechTest < Test::Unit::TestCase
     page = @agent.submit(get_form, get_form.buttons.first)
 
     # Check that the submitted fields exist
-    assert_equal(7, page.links.size, "Not enough links")
+    assert_equal(6, page.links.size, "Not enough links")
     assert_not_nil(
       page.links.find { |l| l.text == "likes ham:on" },
       "likes ham check box missing"
@@ -296,10 +296,6 @@ class FormsMechTest < Test::Unit::TestCase
       page.links.find { |l| l.text == "button.x:9" },
       "Image button missing"
     )
-    assert_not_nil(
-      page.links.find { |l| l.text == "button:button" },
-      "Image button missing"
-    )
   end
 
   def test_post_with_space_in_action
@@ -572,10 +568,10 @@ class FormsMechTest < Test::Unit::TestCase
     form = page.form_with(:name => 'post_form')
 
     assert_not_nil(form)
-    assert_equal(false, form.has_field?('intarweb'))
+    assert(!form.has_field?('intarweb'))
     f = form.add_field!('intarweb')
     assert_not_nil(f)
-    assert_equal(true, form.has_field?('intarweb'))
+    assert(form.has_field?('intarweb'))
   end
 
   def test_field_error

data/test/test_hash_api.rb

@@ -26,8 +26,8 @@ class TestHashApi < Test::Unit::TestCase
 
   def test_get_with_referer
     request = nil
-    @agent.pre_connect_hooks << lambda { |params|
-      request = params[:request]
+    @agent.pre_connect_hooks << lambda { |_, req|
+      request = req
     }
 
     @agent.get( :url => 'http://localhost/',

data/test/test_headers.rb

@@ -25,7 +25,7 @@ class TestHeaders < Test::Unit::TestCase
       when *all_keys
         # ok
       else
-        raise "unexpected key: #{key}"
+        flunk "unexpected key: #{key}"
       end
     }
     assert_equal([], keys)

data/test/test_images.rb

@@ -0,0 +1,19 @@
+require "helper"
+
+class ImagesMechTest < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_base
+    page = @agent.get("http://google.com/tc_base_images.html")
+    assert_equal page.images[0].url, "http://localhost/a.jpg"
+    assert_equal page.images[1].url, "http://localhost/b.gif"
+  end
+
+  def test_base2
+    page = @agent.get("http://google.com/tc_images.html")
+    assert_equal page.images[0].url, "http://google.com/a.jpg"
+    assert_equal page.images[1].url, "http://google.com/b.gif"
+  end
+end

data/test/test_mech.rb

@@ -40,8 +40,8 @@ class TestMechMethods < Test::Unit::TestCase
 
   def test_get_no_referer
     requests = []
-    @agent.pre_connect_hooks << lambda { |params|
-      requests << params[:request]
+    @agent.pre_connect_hooks << lambda { |_, request|
+      requests << request
     }
 
     @agent.get('http://localhost/')
@@ -59,8 +59,8 @@ class TestMechMethods < Test::Unit::TestCase
 
   def test_post_connect_hook_gets_called
     response = nil
-    @agent.post_connect_hooks << lambda { |params|
-      response = params[:response]
+    @agent.post_connect_hooks << lambda { |_, res|
+      response = res
     }
 
     @agent.get('http://localhost/')
@@ -69,8 +69,8 @@ class TestMechMethods < Test::Unit::TestCase
 
   def test_get_with_referer
     request = nil
-    @agent.pre_connect_hooks << lambda { |params|
-      request = params[:request]
+    @agent.pre_connect_hooks << lambda { |_, req|
+      request = req
     }
 
     @agent.get('http://localhost/', URI.parse('http://google.com/'))

data/test/test_mechanize.rb

@@ -0,0 +1,687 @@
+# coding: utf-8
+
+require 'helper'
+
+class TestMechanize < Test::Unit::TestCase
+
+  KEY = OpenSSL::PKey::RSA.new 512
+  name = OpenSSL::X509::Name.parse 'CN=nobody/DC=example'
+  CERT = OpenSSL::X509::Certificate.new
+  CERT.version = 2
+  CERT.serial = 0
+  CERT.not_before = Time.now
+  CERT.not_after = Time.now + 60
+  CERT.public_key = KEY.public_key
+  CERT.subject = name
+  CERT.issuer = name
+  CERT.sign KEY, OpenSSL::Digest::SHA1.new
+
+  def setup
+    @agent = Mechanize.new
+    @uri = URI.parse '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_cert_key_file
+    Tempfile.open 'key' do |key|
+      Tempfile.open 'cert' do |cert|
+        key.write KEY.to_pem
+        key.rewind
+
+        cert.write CERT.to_pem
+        cert.rewind
+
+        agent = Mechanize.new do |a|
+          a.cert = cert.path
+          a.key  = key.path
+        end
+
+        # Certificate#== seems broken
+        assert_equal CERT.to_pem, agent.http.certificate.to_pem
+      end
+    end
+  end
+
+  def test_cert_key_object
+    agent = Mechanize.new do |a|
+      a.cert = CERT
+      a.key  = KEY
+    end
+
+    assert_equal CERT, agent.http.certificate
+  end
+
+  def test_connection_for_file
+    uri = URI.parse 'file:///nonexistent'
+    conn = @agent.connection_for uri
+
+    assert_equal Mechanize::FileConnection.new, conn
+  end
+
+  def test_connection_for_http
+    conn = @agent.connection_for @uri
+
+    assert_equal @agent.http, conn
+  end
+
+  #def test_download
+  #  Dir.mktmpdir do |dir|
+  #    file = "#{dir}/download"
+  #    open file, 'w' do |io|
+  #      @agent.download 'http://example', io
+  #    end
+
+  #    assert_equal 1, File.stat(file).size
+  #  end
+  #end
+
+  def test_enable_gzip
+    @agent.enable_gzip @req
+
+    assert_equal 'gzip,deflate,identity', @req['accept-encoding']
+  end
+
+  def test_enable_gzip_no
+    @agent.gzip_enabled = false
+
+    @agent.enable_gzip @req
+
+    assert_equal 'identity', @req['accept-encoding']
+  end
+
+  def test_fetch_page_file_plus
+    Tempfile.open '++plus++' do |io|
+      content = 'plusses +++'
+      io.write content
+      io.rewind
+
+      uri = URI.parse "file://#{Mechanize::Util.uri_escape io.path}"
+
+      page = @agent.send :fetch_page, uri
+
+      assert_equal content, page.body
+      assert_kind_of Mechanize::File, page
+    end
+  end
+
+  def test_fetch_page_file_space
+    foo = File.expand_path("../htdocs/dir with spaces/foo.html", __FILE__)
+
+    uri = URI.parse "file://#{Mechanize::Util.uri_escape foo}"
+
+    page = @agent.send :fetch_page, uri
+
+    assert_equal File.read(foo), page.body
+    assert_kind_of Mechanize::Page, page
+  end
+
+  def test_fetch_page_file_nonexistent
+    uri = URI.parse 'file:///nonexistent'
+
+    e = assert_raises Mechanize::ResponseCodeError do
+      page = @agent.send :fetch_page, uri
+    end
+
+    assert_equal '404 => Net::HTTPNotFound', e.message
+  end
+
+  def test_get_yield
+    pages = nil
+
+    @agent.get("http://localhost/file_upload.html") { |page|
+      pages = page
+    }
+
+    assert pages
+    assert_equal('File Upload Form', pages.title)
+  end
+
+  def test_http_request_file
+    uri = URI.parse 'file:///nonexistent'
+    request = @agent.http_request uri, :get
+
+    assert_kind_of Mechanize::FileRequest, request
+    assert_equal '/nonexistent', request.path
+  end
+
+  def test_http_request_get
+    request = @agent.http_request @uri, :get
+
+    assert_kind_of Net::HTTP::Get, request
+    assert_equal '/', request.path
+  end
+
+  def test_http_request_post
+    request = @agent.http_request @uri, :post
+
+    assert_kind_of Net::HTTP::Post, request
+    assert_equal '/', request.path
+  end
+
+  def test_post_connect
+    @agent.post_connect_hooks << proc { |agent, response|
+      assert_equal @agent, agent
+      assert_kind_of Net::HTTPResponse, response
+      throw :called
+    }
+
+    assert_throws :called do
+      @agent.post_connect @res
+    end
+  end
+
+  def test_pre_connect
+    @agent.pre_connect_hooks << proc { |agent, request|
+      assert_equal @agent, agent
+      assert_kind_of Net::HTTPRequest, request
+      throw :called
+    }
+
+    assert_throws :called do
+      @agent.pre_connect @req
+    end
+  end
+
+  def test_request_cookies
+    uri = URI.parse 'http://host.example.com'
+    Mechanize::Cookie.parse uri, 'hello=world domain=.example.com' do |cookie|
+      @agent.cookie_jar.add uri, cookie
+    end
+
+    @agent.request_cookies @req, uri
+
+    assert_equal 'hello=world domain=.example.com', @req['Cookie']
+  end
+
+  def test_request_cookies_none
+    @agent.request_cookies @req, @uri
+
+    assert_nil @req['Cookie']
+  end
+
+  def test_request_cookies_many
+    uri = URI.parse 'http://host.example.com'
+    cookie_str = 'a=b domain=.example.com, c=d domain=.example.com'
+    Mechanize::Cookie.parse uri, cookie_str do |cookie|
+      @agent.cookie_jar.add uri, cookie
+    end
+
+    @agent.request_cookies @req, uri
+
+    expected = cookie_str.sub ', ', '; '
+
+    assert_equal expected, @req['Cookie']
+  end
+
+  def test_request_cookies_wrong_domain
+    uri = URI.parse 'http://host.example.com'
+    Mechanize::Cookie.parse uri, 'hello=world domain=.example.com' do |cookie|
+      @agent.cookie_jar.add uri, cookie
+    end
+
+    @agent.request_cookies @req, @uri
+
+    assert_nil @req['Cookie']
+  end
+
+  def test_request_host
+    @agent.request_host @req, @uri
+
+    assert_equal 'example', @req['host']
+  end
+
+  def test_request_host_nonstandard
+    @uri.port = 81
+
+    @agent.request_host @req, @uri
+
+    assert_equal 'example:81', @req['host']
+  end
+
+  def test_request_language_charset
+    @agent.request_language_charset @req
+
+    assert_equal 'en-us,en;q=0.5', @req['accept-language']
+    assert_equal 'ISO-8859-1,utf-8;q=0.7,*;q=0.7', @req['accept-charset']
+  end
+
+  def test_request_add_headers
+    @agent.request_add_headers @req, 'Content-Length' => 300
+
+    assert_equal '300', @req['content-length']
+  end
+
+  def test_request_add_headers_etag
+    @agent.request_add_headers @req, :etag => '300'
+
+    assert_equal '300', @req['etag']
+  end
+
+  def test_request_add_headers_if_modified_since
+    @agent.request_add_headers @req, :if_modified_since => 'some_date'
+
+    assert_equal 'some_date', @req['if-modified-since']
+  end
+
+  def test_request_add_headers_none
+    @agent.request_add_headers @req
+
+    assert_equal @headers, @req.to_hash.keys.sort
+  end
+
+  def test_request_add_headers_request_headers
+    @agent.request_headers['X-Foo'] = 'bar'
+
+    @agent.request_add_headers @req
+
+    assert_equal @headers + %w[x-foo], @req.to_hash.keys.sort
+  end
+
+  def test_request_add_headers_symbol
+    e = assert_raises ArgumentError do
+      @agent.request_add_headers @req, :content_length => 300
+    end
+
+    assert_equal 'unknown header symbol content_length', e.message
+  end
+
+  def test_request_referer
+    referer = URI.parse 'http://old.example'
+
+    @agent.request_referer @req, @uri, referer
+
+    assert_equal 'http://old.example', @req['referer']
+  end
+
+  def test_request_referer_https
+    uri = URI.parse 'https://example'
+    referer = URI.parse 'https://old.example'
+
+    @agent.request_referer @req, uri, referer
+
+    assert_equal 'https://old.example', @req['referer']
+  end
+
+  def test_request_referer_https_downgrade
+    referer = URI.parse 'https://old.example'
+
+    @agent.request_referer @req, @uri, referer
+
+    assert_nil @req['referer']
+  end
+
+  def test_request_referer_https_downgrade_case
+    uri = URI.parse 'http://example'
+    referer = URI.parse 'httpS://old.example'
+
+    @agent.request_referer @req, uri, referer
+
+    assert_nil @req['referer']
+  end
+
+  def test_request_referer_none
+    @agent.request_referer @req, @uri, nil
+
+    assert_nil @req['referer']
+  end
+
+  def test_request_user_agent
+    @agent.request_user_agent @req
+
+    assert_match %r%^Mechanize/#{Mechanize::VERSION}%, @req['user-agent']
+
+    ruby_version = if RUBY_PATCHLEVEL >= 0 then
+                     "#{RUBY_VERSION}p#{RUBY_PATCHLEVEL}"
+                   else
+                     "#{RUBY_VERSION}dev#{RUBY_REVISION}"
+                   end
+
+    assert_match %r%Ruby/#{ruby_version}%, @req['user-agent']
+  end
+
+  def test_resolve_parameters_body
+    input_params = { :q => 'hello' }
+
+    uri, params = @agent.resolve_parameters @uri, :post, input_params
+
+    assert_equal 'http://example/', uri.to_s
+    assert_equal input_params, params
+  end
+
+  def test_resolve_parameters_query
+    uri, params = @agent.resolve_parameters @uri, :get, :q => 'hello'
+
+    assert_equal 'http://example/?q=hello', uri.to_s
+    assert_nil params
+  end
+
+  def test_resolve_parameters_query_append
+    input_params = { :q => 'hello' }
+    @uri.query = 'a=b'
+
+    uri, params = @agent.resolve_parameters @uri, :get, input_params
+
+    assert_equal 'http://example/?a=b&q=hello', uri.to_s
+    assert_nil params
+  end
+
+  def test_response_cookies
+    uri = URI.parse 'http://host.example.com'
+    cookie_str = 'a=b domain=.example.com'
+    @res.instance_variable_set(:@header,
+                               'set-cookie' => [cookie_str],
+                               'content-type' => %w[text/html])
+    page = Mechanize::Page.new uri, @res, '', 200, @agent
+
+    @agent.response_cookies @res, uri, page
+
+    assert_equal ['a=b 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'
+
+    body = <<-BODY
+<head>
+  <meta http-equiv="Set-Cookie" content="#{cookie_str}">
+</head>"
+    BODY
+
+    @res.instance_variable_set(:@header,
+                               'content-type' => %w[text/html])
+    page = Mechanize::Page.new uri, @res, body, 200, @agent
+
+    @agent.response_cookies @res, uri, page
+
+    assert_equal ['a=b domain=.example.com'],
+                 @agent.cookie_jar.cookies(uri).map { |c| c.to_s }
+  end
+
+  def test_response_follow_meta_refresh
+    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, @agent)
+
+    @agent.follow_meta_refresh = true
+
+    page = @agent.response_follow_meta_refresh @res, uri, page, 0
+
+    assert_equal uri, page.uri
+  end
+
+  def test_response_read
+    def @res.read_body() yield 'part' end
+    def @res.content_length() 4 end
+
+    body = @agent.response_read @res, @req
+
+    assert_equal 'part', body
+  end
+
+  def test_response_read_content_length_head
+    req = Net::HTTP::Head.new '/'
+
+    def @res.content_length() end
+    def @res.read_body() end
+
+    body = @agent.response_read @res, req
+
+    assert_equal '', body
+  end
+
+  def test_response_read_content_length_mismatch
+    def @res.content_length() 5 end
+    def @res.read_body() yield 'part' end
+
+    e = assert_raises EOFError do
+      @agent.response_read @res, @req
+    end
+
+    assert_equal 'Content-Length (5) does not match response body length (4)',
+                 e.message
+  end
+
+  def test_response_read_content_length_redirect
+    res = Net::HTTPFound.allocate
+    def res.content_length() 5 end
+    def res.code() 302 end
+    def res.read_body() yield 'part' end
+    res.instance_variable_set :@header, {}
+
+    body = @agent.response_read res, @req
+
+    assert_equal 'part', body
+  end
+
+  def test_response_read_encoding_7_bit
+    def @res.read_body() yield 'part' end
+    def @res.content_length() 4 end
+    @res.instance_variable_set :@header, 'content-encoding' => %w[7bit]
+
+    body = @agent.response_read @res, @req
+
+    assert_equal 'part', body
+  end
+
+  def test_response_read_encoding_deflate
+    def @res.read_body()
+      yield "x\x9C+H,*\x01\x00\x04?\x01\xB8"
+    end
+    def @res.content_length() 12 end
+    @res.instance_variable_set :@header, 'content-encoding' => %w[deflate]
+
+    body = @agent.response_read @res, @req
+
+    assert_equal 'part', body
+  end
+
+  # IIS/6.0 ASP.NET/2.0.50727 does not wrap deflate with zlib, WTF?
+  def test_response_read_encoding_deflate_no_zlib
+    def @res.read_body()
+      yield "+H,*\001\000"
+    end
+    def @res.content_length() 6 end
+    @res.instance_variable_set :@header, 'content-encoding' => %w[deflate]
+
+    body = @agent.response_read @res, @req
+
+    assert_equal 'part', body
+  end
+
+  def test_response_read_encoding_gzip
+    def @res.read_body()
+      yield "\037\213\b\0002\002\225M\000\003"
+      yield "+H,*\001\000\306p\017I\004\000\000\000"
+    end
+    def @res.content_length() 24 end
+    @res.instance_variable_set :@header, 'content-encoding' => %w[gzip]
+
+    body = @agent.response_read @res, @req
+
+    assert_equal 'part', body
+  end
+
+  def test_response_read_encoding_none
+    def @res.read_body() yield 'part' end
+    def @res.content_length() 4 end
+    @res.instance_variable_set :@header, 'content-encoding' => %w[none]
+
+    body = @agent.response_read @res, @req
+
+    assert_equal 'part', body
+  end
+
+  def test_response_read_encoding_x_gzip
+    def @res.read_body()
+      yield "\037\213\b\0002\002\225M\000\003"
+      yield "+H,*\001\000\306p\017I\004\000\000\000"
+    end
+    def @res.content_length() 24 end
+    @res.instance_variable_set :@header, 'content-encoding' => %w[x-gzip]
+
+    body = @agent.response_read @res, @req
+
+    assert_equal 'part', body
+  end
+
+  def test_response_read_encoding_unknown
+    def @res.read_body() yield 'part' end
+    def @res.content_length() 4 end
+    @res.instance_variable_set :@header, 'content-encoding' => %w[unknown]
+
+    e = assert_raises Mechanize::Error do
+      @agent.response_read @res, @req
+    end
+
+    assert_equal 'Unsupported Content-Encoding: unknown', e.message
+  end
+
+  def test_response_read_file
+    Tempfile.open 'pi.txt' do |tempfile|
+      tempfile.write "π\n"
+      tempfile.flush
+      tempfile.rewind
+
+      uri = URI.parse "file://#{tempfile.path}"
+      req = Mechanize::FileRequest.new uri
+      res = Mechanize::FileResponse.new tempfile.path
+
+      body = @agent.response_read res, req
+
+      expected = "π\n"
+      expected.force_encoding Encoding::BINARY if expected.respond_to? :encoding
+
+      assert_equal expected, body
+      assert_equal Encoding::BINARY, body.encoding if body.respond_to? :encoding
+    end
+  end
+
+  def test_response_read_no_body
+    req = Net::HTTP::Options.new '/'
+
+    def @res.content_length() end
+    def @res.read_body() end
+
+    body = @agent.response_read @res, req
+
+    assert_equal '', body
+  end
+
+  def test_response_read_unknown_code
+    res = Net::HTTPUnknownResponse.allocate
+    res.instance_variable_set :@code, 9999
+    def res.read_body() yield 'part' end
+
+    e = assert_raises Mechanize::ResponseCodeError do
+      @agent.response_read res, @req
+    end
+
+    assert_equal res, e.page
+  end
+
+  def test_response_parse
+    body = '<title>hi</title>'
+    @res.instance_variable_set :@header, 'content-type' => %w[text/html]
+
+    page = @agent.response_parse @res, body, @uri
+
+    assert_instance_of Mechanize::Page, page
+    assert_equal @agent, page.mech
+  end
+
+  def test_response_parse_content_type_case
+    body = '<title>hi</title>'
+    @res.instance_variable_set(:@header, 'content-type' => %w[text/HTML])
+
+    page = @agent.response_parse @res, body, @uri
+
+    assert_instance_of Mechanize::Page, page
+
+    assert_equal 'text/HTML', page.content_type
+  end
+
+  def test_response_parse_content_type_encoding
+    body = '<title>hi</title>'
+    @res.instance_variable_set(:@header,
+                               'content-type' =>
+                                 %w[text/html;charset=ISO-8859-1])
+
+    page = @agent.response_parse @res, body, @uri
+
+    assert_instance_of Mechanize::Page, page
+    assert_equal @agent, page.mech
+
+    assert_equal 'ISO-8859-1', page.encoding
+    assert_equal 'ISO-8859-1', page.parser.encoding
+  end
+
+  def test_response_parse_content_type_encoding_garbage
+    body = '<title>hi</title>'
+    @res.instance_variable_set(:@header,
+                               'content-type' =>
+                                 %w[text/html; charset=garbage_charset])
+
+    page = @agent.response_parse @res, body, @uri
+
+    assert_instance_of Mechanize::Page, page
+    assert_equal @agent, page.mech
+  end
+
+  def test_response_parse_content_type_encoding_broken_iso_8859_1
+    body = '<title>hi</title>'
+    @res.instance_variable_set(:@header,
+                               'content-type' =>
+                                 %w[text/html; charset=ISO_8859-1])
+
+    page = @agent.response_parse @res, body, @uri
+
+    assert_instance_of Mechanize::Page, page
+    assert_equal 'ISO_8859-1', page.encoding
+  end
+
+  def test_response_parse_content_type_encoding_broken_utf_8
+    body = '<title>hi</title>'
+    @res.instance_variable_set(:@header,
+                               'content-type' =>
+                                 %w[text/html; charset=UTF8])
+
+    page = @agent.response_parse @res, body, @uri
+
+    assert_instance_of Mechanize::Page, page
+    assert_equal 'UTF8', page.encoding
+    assert_equal 'UTF8', page.parser.encoding
+  end
+
+  def test_response_parse_content_type_encoding_semicolon
+    body = '<title>hi</title>'
+    @res.instance_variable_set(:@header,
+                               'content-type' =>
+                                 %w[text/html;charset=UTF-8;])
+
+    page = @agent.response_parse @res, body, @uri
+
+    assert_instance_of Mechanize::Page, page
+
+    assert_equal 'UTF-8', page.encoding
+  end
+
+end
+