mechanize 2.7.3 → 2.7.4

data/test/test_mechanize_form.rb

@@ -651,6 +651,25 @@ class TestMechanizeForm < Mechanize::TestCase
            "Image button missing")
   end
 
+  def test_reset
+    page = @mech.get("http://localhost/form_test.html")
+    get_form = page.forms.find { |f| f.name == "get_form1" }
+
+    image_button = get_form.buttons.first
+    submit_button = get_form.submits.first
+
+    new_page = @mech.submit(get_form, submit_button)
+    assert_equal "http://localhost/form_post?first_name=", new_page.uri.to_s
+
+    new_page = @mech.submit(get_form, image_button)
+    assert_equal "http://localhost/form_post?first_name=&button.x=0&button.y=0", new_page.uri.to_s
+
+    get_form.reset
+
+    new_page = @mech.submit(get_form, submit_button)
+    assert_equal "http://localhost/form_post?first_name=", new_page.uri.to_s
+  end
+
   def test_post_with_space_in_action
     page = @mech.get("http://localhost/form_test.html")
     post_form = page.forms.find { |f| f.name == "post_form2" }

data/test/test_mechanize_form_encoding.rb

@@ -8,15 +8,10 @@ class TestMechanizeFormEncoding < Mechanize::TestCase
 
   INPUTTED_VALUE = "テスト" # "test" in Japanese UTF-8 encoding
   CONTENT_ENCODING = 'Shift_JIS' # one of Japanese encoding
-  encoded_value = "\x83\x65\x83\x58\x83\x67" # "test" in Japanese Shift_JIS encoding
-  encoded_value.force_encoding(::Encoding::SHIFT_JIS) if encoded_value.respond_to?(:force_encoding)
+  encoded_value = "\x83\x65\x83\x58\x83\x67".force_encoding(::Encoding::SHIFT_JIS) # "test" in Japanese Shift_JIS encoding
   EXPECTED_QUERY = "first_name=#{CGI.escape(encoded_value)}&first_name=&gender=&green%5Beggs%5D="
 
-  if Mechanize::Util::NEW_RUBY_ENCODING
-    ENCODING_ERRORS = [EncodingError, Encoding::ConverterNotFoundError] # and so on
-  else
-    ENCODING_ERRORS = [Iconv::InvalidEncoding, Iconv::IllegalSequence]
-  end
+  ENCODING_ERRORS = [EncodingError, Encoding::ConverterNotFoundError] # and so on
 
   ENCODING_LOG_MESSAGE = /INFO -- : form encoding: Shift_JIS/
   INVALID_ENCODING = 'UTF-eight'

data/test/test_mechanize_http_agent.rb

@@ -18,10 +18,8 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
 
     @headers = if RUBY_VERSION >= '2.0.0' then
                  %w[accept accept-encoding user-agent]
-               elsif RUBY_VERSION >= '1.9.0' then
-                 %w[accept user-agent]
                else
-                 %w[accept]
+                 %w[accept user-agent]
                end
   end
 
@@ -33,6 +31,16 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
     realm
   end
 
+  def jruby_zlib?
+    if RUBY_ENGINE == 'jruby'
+      meth = caller[0][/`(\w+)/, 1]
+      warn "#{meth}: skipped because how Zlib handles error is different in JRuby"
+      true
+    else
+      false
+    end
+  end
+
   def test_agent_is_named
     assert_equal 'mechanize', Mechanize::HTTP::Agent.new.http.name
     assert_equal 'unique', Mechanize::HTTP::Agent.new('unique').http.name
@@ -494,6 +502,12 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
 
     assert_match %r%^Digest %, @req['Authorization']
     assert_match %r%qop=auth%, @req['Authorization']
+
+    @req['Authorization'] = nil
+    @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
@@ -913,6 +927,8 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
     body_io = StringIO.new \
       "\037\213\b\0002\002\225M\000\003+H,*\001"
 
+    return if jruby_zlib?
+
     e = assert_raises Mechanize::Error do
       @agent.response_content_encoding @res, body_io
     end
@@ -944,6 +960,8 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
     assert body_io.closed?
 
     assert_match %r%invalid compressed data -- crc error%, log.string
+  rescue IOError
+    raise unless jruby_zlib?
   end
 
   def test_response_content_encoding_gzip_checksum_corrupt_length
@@ -960,6 +978,8 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
     assert body_io.closed?
 
     assert_match %r%invalid compressed data -- length error%, log.string
+  rescue IOError
+    raise unless jruby_zlib?
   end
 
   def test_response_content_encoding_gzip_checksum_truncated
@@ -976,6 +996,8 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
     assert body_io.closed?
 
     assert_match %r%unable to gunzip response: footer is not found%, log.string
+  rescue IOError
+    raise unless jruby_zlib?
   end
 
   def test_response_content_encoding_gzip_empty
@@ -1015,6 +1037,8 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
     assert_equal 'part', body.read
 
     assert body_io.closed?
+  rescue IOError
+    raise unless jruby_zlib?
   end
 
   def test_response_content_encoding_none
@@ -1193,6 +1217,24 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
     end
   end
 
+  def test_response_meta_refresh_with_insecure_url
+    uri = URI.parse 'http://example/#id+1'
+
+    body = <<-BODY
+<title></title>
+<meta http-equiv="refresh" content="0; url=file:///dev/zero">
+    BODY
+
+    page = Mechanize::Page.new(uri, nil, body, 200, @mech)
+
+    @agent.follow_meta_refresh = true
+
+    assert_raises Mechanize::Error do
+      @agent.response_follow_meta_refresh(@res, uri, page,
+                                          @agent.redirection_limit)
+    end
+  end
+
   def test_response_parse
     body = '<title>hi</title>'
     @res.instance_variable_set :@header, 'content-type' => %w[text/html]
@@ -1288,7 +1330,7 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
     body = io.read
 
     assert_equal 'part', body
-    assert_equal Encoding::BINARY, body.encoding if body.respond_to? :encoding
+    assert_equal Encoding::BINARY, body.encoding
   end
 
   def test_response_read_chunked_no_trailer
@@ -1368,17 +1410,15 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
 
       io = @agent.response_read res, req, uri
 
-      expected = "π\n"
-      expected.force_encoding Encoding::BINARY if expected.respond_to? :encoding
+      expected = "π\n".force_encoding(Encoding::BINARY)
 
       # Ruby 1.8.7 doesn't let us set the write mode of the tempfile to binary,
       # so we should expect an inserted carriage return on some platforms
-      expected_with_carriage_return = "π\r\n"
-      expected_with_carriage_return.force_encoding Encoding::BINARY if expected_with_carriage_return.respond_to? :encoding
+      expected_with_carriage_return = "π\r\n".force_encoding(Encoding::BINARY)
 
       body = io.read
       assert_match(/^(#{expected}|#{expected_with_carriage_return})$/m, body)
-      assert_equal Encoding::BINARY, body.encoding if body.respond_to? :encoding
+      assert_equal Encoding::BINARY, body.encoding
     end
   end
 
@@ -1479,6 +1519,16 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
     assert_equal 'http://example/referer', requests.first['Referer']
   end
 
+  def test_response_redirect_insecure
+    @agent.redirect_ok = true
+    referer = page 'http://example/referer'
+
+    assert_raises Mechanize::Error do
+      @agent.response_redirect({ 'Location' => 'file:///etc/passwd' }, :get,
+                               fake_page, 0, {}, referer)
+    end
+  end
+
   def test_response_redirect_limit
     @agent.redirect_ok = true
     referer = page 'http://example/referer'
@@ -1601,7 +1651,7 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
       @agent.cert_store = store
       @agent.certificate = ssl_certificate
       @agent.private_key = ssl_private_key
-      @agent.ssl_version = 'SSLv3' if RUBY_VERSION > '1.9'
+      @agent.ssl_version = 'SSLv3'
       @agent.verify_callback = proc { |ok, context| }
 
       http = @agent.http
@@ -1610,8 +1660,7 @@ class TestMechanizeHttpAgent < Mechanize::TestCase
       assert_equal store,                     http.cert_store
       assert_equal ssl_certificate,           http.certificate
       assert_equal ssl_private_key,           http.private_key
-      assert_equal 'SSLv3',                   http.ssl_version if
-        RUBY_VERSION > '1.9'
+      assert_equal 'SSLv3',                   http.ssl_version
       assert_equal OpenSSL::SSL::VERIFY_PEER, http.verify_mode
       assert http.verify_callback
     end

data/test/test_mechanize_http_www_authenticate_parser.rb

@@ -117,6 +117,14 @@ class TestMechanizeHttpWwwAuthenticateParser < Mechanize::TestCase
     assert_equal expected, @parser.parse('BaSiC realm=foo')
   end
 
+  def test_parse_bad_whitespace_around_auth_param
+    expected = [
+      challenge('Basic', { 'realm' => 'foo' }, 'Basic realm = "foo"'),
+    ]
+
+    assert_equal expected, @parser.parse('Basic realm = "foo"')
+  end
+
   def test_quoted_string
     @parser.scanner = StringScanner.new '"text"'
 

data/test/test_mechanize_link.rb

@@ -32,7 +32,13 @@ class TestMechanizeLink < Mechanize::TestCase
     page = @mech.get("http://google.com/tc_links.html")
     link = page.link_with(:text => 'javascript link')
     assert_raises Mechanize::UnsupportedSchemeError do
-      link.click
+      begin
+        link.click
+      rescue Mechanize::UnsupportedSchemeError => error
+          assert_equal 'javascript', error.scheme
+          assert_equal "javascript:new_page('1')", error.uri.to_s
+        raise
+      end
     end
 
     @mech.scheme_handlers['javascript'] = lambda { |my_link, my_page|
@@ -110,5 +116,12 @@ class TestMechanizeLink < Mechanize::TestCase
     assert_equal 'http://foo.bar/%20baz', link.uri.to_s
   end
 
+  def test_resolving_full_uri
+    page = @mech.get("http://localhost/frame_test.html")
+    link = page.link_with(:text => "Form Test")
+
+    assert_equal "/form_test.html", link.uri.to_s
+    assert_equal "http://localhost/form_test.html", link.resolved_uri.to_s
+  end
 end
 

data/test/test_mechanize_page.rb

@@ -8,6 +8,42 @@ class TestMechanizePage < Mechanize::TestCase
     @uri = URI 'http://example/'
   end
 
+  def test_selector_methods
+    page = html_page <<-BODY
+<html>
+  <meta>
+  <head><title></title>
+  <body>
+    <span class="name" id="out">Eamonn</span>
+    <span>/</span>
+    <span class="name" id="bloody">Esther</span>
+    <span>/</span>
+    <span class="name" id="rageous">Fletcher</span>
+  </body>
+</html>
+    BODY
+
+    # at(css_selector), % css_selector
+    assert_equal('Eamonn', page.at('#out').text)
+    assert_equal('Eamonn', (page % '#out').text)
+
+    # at(xpath_selector), % xpath_selector
+    assert_equal('Esther', page.at('//span[@id="bloody"]').text)
+    assert_equal('Esther', (page % '//span[@id="bloody"]').text)
+
+    # at_css()
+    assert_equal('Eamonn', page.at_css('#out').text)
+
+    # css()
+    assert_equal('Fletcher', page.css('.name')[2].text)
+
+    # at_xpath()
+    assert_equal('Esther', page.at_xpath('//span[@id="bloody"]').text)
+
+    # xpath()
+    assert_equal('Fletcher', page.xpath('//*[@class="name"]')[2].text)
+  end
+
   def test_initialize_good_content_type
     page = Mechanize::Page.new
     assert_equal('text/html', page.content_type)
@@ -174,6 +210,7 @@ class TestMechanizePage < Mechanize::TestCase
   <meta>
   <head><title></title>
   <body>
+    <img src="1.jpg" class="unpretty">
     <img src="a.jpg" class="pretty">
     <img src="b.jpg">
     <img src="c.png" class="pretty">
@@ -181,14 +218,24 @@ class TestMechanizePage < Mechanize::TestCase
 </html>
     BODY
 
-    images = page.images_with(:search => "//img[@class='pretty']")
+    {
+      :search => "//img[@class='pretty']",
+      :xpath => "//img[@class='pretty']",
+      :css => "img.pretty",
+      :class => "pretty",
+      :dom_class => "pretty",
+    }.each { |key, expr|
+      images = page.images_with(key => expr)
 
-    assert_equal 2, images.size
-    assert_equal "pretty", images[0].dom_class
-    assert_equal "a.jpg", images[0].src
+      message = "selecting with #{key.inspect}"
 
-    assert_equal "pretty", images[1].dom_class
-    assert_equal "c.png", images[1].src
+      assert_equal 2, images.size
+      assert_equal "pretty", images[0].dom_class, message
+      assert_equal "a.jpg", images[0].src, message
+
+      assert_equal "pretty", images[1].dom_class, message
+      assert_equal "c.png", images[1].src, message
+    }
   end
 
   def test_search_bad_selectors

data/test/test_mechanize_page_encoding.rb

@@ -5,7 +5,7 @@ require 'mechanize/test_case'
 
 class TestMechanizePageEncoding < Mechanize::TestCase
 
-  MECH_ASCII_ENCODING = Mechanize::Util::NEW_RUBY_ENCODING ? 'US-ASCII' : 'ISO-8859-1'
+  MECH_ASCII_ENCODING = 'US-ASCII'
 
   def setup
     super
@@ -16,8 +16,7 @@ class TestMechanizePageEncoding < Mechanize::TestCase
   end
 
   def util_page body = @body, headers = @response_headers
-    body.force_encoding Encoding::BINARY if body.respond_to? :force_encoding
-    Mechanize::Page.new @uri, headers, body, 200, @mech
+    Mechanize::Page.new @uri, headers, body && body.force_encoding(Encoding::BINARY), 200, @mech
   end
 
   def test_page_charset

data/test/test_mechanize_page_link.rb

@@ -48,8 +48,17 @@ class TestMechanizePageLink < Mechanize::TestCase
   end
 
   def util_page body = @body, res = @res
-    body.force_encoding Encoding::BINARY if body.respond_to? :force_encoding
-    Mechanize::Page.new @uri, res, body, 200, @mech
+    Mechanize::Page.new @uri, res, body && body.force_encoding(Encoding::BINARY), 200, @mech
+  end
+
+  def nkf_dependency?
+    if RUBY_ENGINE == 'ruby'
+      false
+    else
+      meth = caller[0][/`(\w+)/, 1]
+      warn "#{meth}: skipped because this feature currently depends on NKF"
+      true
+    end
   end
 
   def test_override_content_type
@@ -103,6 +112,8 @@ class TestMechanizePageLink < Mechanize::TestCase
   end
 
   def test_encoding_charset_after_title_bad
+    return if nkf_dependency?
+
     page = util_page UTF8
 
     assert_equal false, page.encoding_error?
@@ -111,6 +122,8 @@ class TestMechanizePageLink < Mechanize::TestCase
   end
 
   def test_encoding_charset_after_title_double_bad
+    return if nkf_dependency?
+
     page = util_page SJIS_BAD_AFTER_TITLE
 
     assert_equal false, page.encoding_error?
@@ -119,6 +132,8 @@ class TestMechanizePageLink < Mechanize::TestCase
   end
 
   def test_encoding_charset_bad
+    return if nkf_dependency?
+
     page = util_page "<title>#{UTF8_TITLE}</title>"
     page.encodings.replace %w[
       UTF-8

data/test/test_mechanize_util.rb

@@ -6,16 +6,10 @@ class TestMechanizeUtil < Mechanize::TestCase
 
   INPUTTED_VALUE = "テスト" # "test" in Japanese UTF-8 encoding
   CONTENT_ENCODING = 'Shift_JIS' # one of Japanese encoding
-  ENCODED_VALUE = "\x83\x65\x83\x58\x83\x67" # "test" in Japanese Shift_JIS encoding
-
-  if Mechanize::Util::NEW_RUBY_ENCODING
-    ENCODING_ERRORS = [EncodingError, Encoding::ConverterNotFoundError] # and so on
-    ERROR_LOG_MESSAGE = /from_native_charset: Encoding::ConverterNotFoundError: form encoding: "UTF-eight"/
-    ENCODED_VALUE.force_encoding(::Encoding::SHIFT_JIS)
-  else
-    ENCODING_ERRORS = [Iconv::InvalidEncoding, Iconv::IllegalSequence]
-    ERROR_LOG_MESSAGE = /from_native_charset: Iconv::InvalidEncoding: form encoding: "UTF-eight"/
-  end
+  ENCODED_VALUE = "\x83\x65\x83\x58\x83\x67".force_encoding(::Encoding::SHIFT_JIS) # "test" in Japanese Shift_JIS encoding
+
+  ENCODING_ERRORS = [EncodingError, Encoding::ConverterNotFoundError] # and so on
+  ERROR_LOG_MESSAGE = /from_native_charset: Encoding::ConverterNotFoundError: form encoding: "UTF-eight"/
 
   INVALID_ENCODING = 'UTF-eight'
 
@@ -104,5 +98,46 @@ class TestMechanizeUtil < Mechanize::TestCase
     assert_equal "%",   @MU.uri_escape("%", /[^%]/)
   end
 
+  def test_build_query_string_simple
+    input_params = [
+      [:ids, 1],
+      [:action, 'delete'],
+      [:ids, 5],
+    ]
+
+    expected_params = [
+      ['ids', '1'],
+      ['action', 'delete'],
+      ['ids', '5'],
+    ]
+
+    query = @MU.build_query_string(input_params)
+
+    assert_equal expected_params, URI.decode_www_form(query)
+  end
+
+  def test_build_query_string_complex
+    input_params = {
+      number: 7,
+      name: "\u{6B66}\u{8005}",
+      "ids[]" => [1, 3, 5, 7],
+      words: ["Sing", "Now!"],
+      params: { x: "50%", y: "100%", t: [80, 160] },
+    }
+
+    expected_params = [
+      ['number', '7'],
+      ['name', "\u{6B66}\u{8005}"],
+      ['ids[]', '1'], ['ids[]', '3'], ['ids[]', '5'], ['ids[]', '7'],
+      ['words', 'Sing'], ['words', 'Now!'],
+      ['params[x]', '50%'],
+      ['params[y]', '100%'],
+      ['params[t]', '80'], ['params[t]', '160'],
+    ]
+
+    query = @MU.build_query_string(input_params)
+
+    assert_equal expected_params, URI.decode_www_form(query)
+  end
 end