mechanize 2.14.1 → 2.14.2

data/test/test_mechanize_parser.rb

@@ -1,316 +0,0 @@
-# frozen_string_literal: true
-require 'mechanize/test_case'
-
-class TestMechanizeParser < Mechanize::TestCase
-
-  class P
-    include Mechanize::Parser
-
-    attr_accessor :filename
-    attr_accessor :response
-    attr_accessor :uri
-
-    def initialize
-      @uri = URI 'http://example'
-      @full_path = false
-    end
-  end
-
-  def setup
-    super
-
-    @parser = P.new
-  end
-
-  def test_extract_filename
-    @parser.response = {}
-
-    assert_equal 'index.html', @parser.extract_filename
-  end
-
-  def test_extract_filename_content_disposition
-    @parser.uri = URI 'http://example/foo'
-
-    @parser.response = {
-      'content-disposition' => 'attachment; filename=genome.jpeg'
-    }
-
-    assert_equal 'genome.jpeg', @parser.extract_filename
-  end
-
-  def test_extract_filename_content_disposition_bad
-    @parser.uri = URI 'http://example/foo'
-
-    @parser.response = {
-      'content-disposition' => "inline; filename*=UTF-8''X%20Y.jpg"
-    }
-
-    assert_equal 'foo.html', @parser.extract_filename
-
-    @parser.response = {
-      'content-disposition' => "inline; filename=\"\""
-    }
-
-    assert_equal 'foo.html', @parser.extract_filename
-  end
-
-  def test_extract_filename_content_disposition_path
-    @parser.uri = URI 'http://example'
-
-    @parser.response = {
-      'content-disposition' => 'attachment; filename="../genome.jpeg"'
-    }
-
-    assert_equal 'example/genome.jpeg', @parser.extract_filename(true)
-
-    @parser.response = {
-      'content-disposition' => 'attachment; filename="foo/genome.jpeg"'
-    }
-
-    assert_equal 'example/genome.jpeg', @parser.extract_filename(true)
-  end
-
-  def test_extract_filename_content_disposition_path_windows
-    @parser.uri = URI 'http://example'
-
-    @parser.response = {
-      'content-disposition' => 'attachment; filename="..\\\\genome.jpeg"'
-    }
-
-    assert_equal 'example/genome.jpeg', @parser.extract_filename(true)
-
-    @parser.response = {
-      'content-disposition' => 'attachment; filename="foo\\\\genome.jpeg"'
-    }
-
-    assert_equal 'example/genome.jpeg', @parser.extract_filename(true)
-  end
-
-  def test_extract_filename_content_disposition_full_path
-    @parser.uri = URI 'http://example/foo'
-
-    @parser.response = {
-      'content-disposition' => 'attachment; filename=genome.jpeg'
-    }
-
-    assert_equal 'example/genome.jpeg', @parser.extract_filename(true)
-  end
-
-  def test_extract_filename_content_disposition_quoted
-    @parser.uri = URI 'http://example'
-
-    @parser.response = {
-      'content-disposition' => 'attachment; filename="\"some \"file\""'
-    }
-
-    assert_equal '_some__file_', @parser.extract_filename
-  end
-
-  def test_extract_filename_content_disposition_special
-    @parser.uri = URI 'http://example/foo'
-
-    @parser.response = {
-      'content-disposition' => 'attachment; filename="/\\\\<>:\\"|?*"'
-    }
-
-    assert_equal '_______', @parser.extract_filename
-
-    chars = (0..12).map { |c| c.chr }.join
-    chars += "\\\r"
-    chars += (14..31).map { |c| c.chr }.join
-
-    @parser.response = {
-      'content-disposition' => "attachment; filename=\"#{chars}\""
-    }
-
-    assert_equal '_' * 32, @parser.extract_filename
-  end
-
-  def test_extract_filename_content_disposition_windows_special
-    @parser.uri = URI 'http://example'
-
-    windows_special = %w[
-      AUX
-      COM1
-      COM2
-      COM3
-      COM4
-      COM5
-      COM6
-      COM7
-      COM8
-      COM9
-      CON
-      LPT1
-      LPT2
-      LPT3
-      LPT4
-      LPT5
-      LPT6
-      LPT7
-      LPT8
-      LPT9
-      NUL
-      PRN
-    ]
-
-    windows_special.each do |special|
-      @parser.response = {
-        'content-disposition' => "attachment; filename=#{special}"
-      }
-
-      assert_equal "_#{special}", @parser.extract_filename
-    end
-  end
-
-  def test_extract_filename_content_disposition_empty
-    @parser.uri = URI 'http://example'
-
-    @parser.response = {
-      'content-disposition' => 'inline; filename="/"'
-    }
-
-    assert_equal '', @parser.extract_filename
-  end
-
-  def test_extract_filename_host
-    @parser.response = {}
-    @parser.uri = URI 'http://example'
-
-    assert_equal 'example/index.html', @parser.extract_filename(true)
-  end
-
-  def test_extract_filename_special_character
-    @parser.response = {}
-
-    invisible = "\t\n\v\f\r"
-
-    invisible.chars.each do |char|
-      begin
-        @parser.uri = URI "http://example/#{char}"
-
-        assert_equal 'index.html', @parser.extract_filename, char.inspect
-      rescue URI::InvalidURIError
-        # ignore
-      end
-    end
-
-    escaped = "<>\"\\|"
-
-    escaped.chars.each do |char|
-      escaped_char = CGI.escape char
-
-      @parser.uri = URI "http://example/#{escaped_char}"
-
-      assert_equal "#{escaped_char}.html", @parser.extract_filename, char
-    end
-
-    @parser.uri = URI "http://example/?"
-
-    assert_equal 'index.html_', @parser.extract_filename, 'empty query'
-
-    @parser.uri = URI "http://example/:"
-
-    assert_equal '_.html', @parser.extract_filename, 'colon'
-
-    @parser.uri = URI "http://example/*"
-
-    assert_equal '_.html', @parser.extract_filename, 'asterisk'
-  end
-
-  def test_extract_filename_uri
-    @parser.response = {}
-    @parser.uri = URI 'http://example/foo'
-
-    assert_equal 'foo.html', @parser.extract_filename
-
-    @parser.uri += '/foo.jpg'
-
-    assert_equal 'foo.jpg', @parser.extract_filename
-  end
-
-  def test_extract_filename_uri_full_path
-    @parser.response = {}
-    @parser.uri = URI 'http://example/foo'
-
-    assert_equal 'example/foo.html', @parser.extract_filename(true)
-
-    @parser.uri += '/foo.jpg'
-
-    assert_equal 'example/foo.jpg', @parser.extract_filename(true)
-  end
-
-  def test_extract_filename_uri_query
-    @parser.response = {}
-    @parser.uri = URI 'http://example/?id=5'
-
-    assert_equal 'index.html_id=5', @parser.extract_filename
-
-    @parser.uri += '/foo.html?id=5'
-
-    assert_equal 'foo.html_id=5', @parser.extract_filename
-  end
-
-  def test_extract_filename_uri_slash
-    @parser.response = {}
-    @parser.uri = URI 'http://example/foo/'
-
-    assert_equal 'example/foo/index.html', @parser.extract_filename(true)
-
-    @parser.uri += '/foo///'
-
-    assert_equal 'example/foo/index.html', @parser.extract_filename(true)
-  end
-
-  def test_extract_filename_windows_special
-    @parser.uri = URI 'http://example'
-    @parser.response = {}
-
-    windows_special = %w[
-      AUX
-      COM1
-      COM2
-      COM3
-      COM4
-      COM5
-      COM6
-      COM7
-      COM8
-      COM9
-      CON
-      LPT1
-      LPT2
-      LPT3
-      LPT4
-      LPT5
-      LPT6
-      LPT7
-      LPT8
-      LPT9
-      NUL
-      PRN
-    ]
-
-    windows_special.each do |special|
-      @parser.uri += "/#{special}"
-
-      assert_equal "_#{special}.html", @parser.extract_filename
-    end
-  end
-
-  def test_fill_header
-    @parser.fill_header 'a' => 'b'
-
-    expected = { 'a' => 'b' }
-
-    assert_equal expected, @parser.response
-  end
-
-  def test_fill_header_nil
-    @parser.fill_header nil
-
-    assert_empty @parser.response
-  end
-
-end
-

data/test/test_mechanize_pluggable_parser.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-require 'mechanize/test_case'
-
-class TestMechanizePluggableParser < Mechanize::TestCase
-
-  def setup
-    super
-
-    @pp = @mech.pluggable_parser
-  end
-
-  def test_aref
-    @pp['text/html'] = Mechanize::Download
-
-    assert_equal Mechanize::Download, @pp['text/html']
-  end
-
-  def test_csv
-    @pp.csv = Mechanize::Download
-
-    assert_equal Mechanize::Download, @pp['text/csv']
-  end
-
-  def test_html
-    assert_equal Mechanize::Page, @pp['text/html']
-
-    @pp.html = Mechanize::Download
-
-    assert_equal Mechanize::Download, @pp['text/html']
-  end
-
-  def test_parser
-    assert_equal Mechanize::XmlFile, @pp.parser('text/xml')
-    assert_equal Mechanize::File, @pp.parser(nil)
-  end
-
-  def test_parser_mime
-    @pp['image/png'] = :png
-
-    assert_equal :png, @pp.parser('x-image/x-png')
-    assert_equal :png, @pp.parser('image/png')
-    assert_equal Mechanize::Image, @pp.parser('image')
-  end
-
-  def test_parser_bogus
-    assert_nil @pp['bogus']
-
-    assert_equal Mechanize::File, @pp.parser('bogus')
-  end
-
-  def test_pdf
-    @pp.pdf = Mechanize::Download
-
-    assert_equal Mechanize::Download, @pp['application/pdf']
-  end
-
-  def test_xml
-    assert_equal Mechanize::XmlFile, @pp['text/xml']
-    assert_equal Mechanize::XmlFile, @pp['application/xml']
-
-    @pp.xml = Mechanize::Download
-
-    assert_equal Mechanize::Download, @pp['text/xml']
-    assert_equal Mechanize::Download, @pp['application/xml']
-  end
-
-end
-

data/test/test_mechanize_redirect_limit_reached_error.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-require 'mechanize/test_case'
-
-class TestMechanizeRedirectLimitReachedError < Mechanize::TestCase
-
-  def setup
-    super
-
-    @error = Mechanize::RedirectLimitReachedError.new fake_page, 10
-  end
-
-  def test_message
-    assert_equal 'Redirect limit of 10 reached', @error.message
-  end
-
-  def test_redirects
-    assert_equal 10, @error.redirects
-  end
-
-  def test_response_code
-    assert_equal 200, @error.response_code
-  end
-
-end
-

data/test/test_mechanize_redirect_not_get_or_head_error.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-require 'mechanize/test_case'
-
-class TestMechanizeRedirectNotGetOrHead < Mechanize::TestCase
-
-  def test_to_s
-    page = fake_page
-
-    error = Mechanize::RedirectNotGetOrHeadError.new(page, :put)
-
-    assert_match(/ PUT /, error.to_s)
-  end
-
-end
-

data/test/test_mechanize_response_read_error.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-require 'mechanize/test_case'
-
-class TestMechanizeResponseReadError < Mechanize::TestCase
-
-  def setup
-    super
-
-    @error = 'error message'
-    @response = Response.new
-    @response['content-length'] = 3
-    @body_io = StringIO.new 'body'
-  end
-
-  def test_force_parse
-    @response['content-type'] = 'text/html'
-    uri = URI 'http://example/'
-
-    e = Mechanize::ResponseReadError.new @error, @response, @body_io, uri, @mech
-
-    page = e.force_parse
-
-    assert_kind_of Mechanize::Page, page
-    assert_equal 'body',            page.body
-    assert_equal @mech,             page.mech
-  end
-
-end
-

data/test/test_mechanize_subclass.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-require 'mechanize/test_case'
-
-class TestMechanizeSubclass < Mechanize::TestCase
-
-  class Parent < Mechanize
-    @html_parser = :parser
-    @log = :log
-  end
-
-  class Child < Parent
-  end
-
-  def test_subclass_inherits_html_parser
-    assert_equal :parser, Child.html_parser
-  end
-
-  def test_subclass_inherits_log
-    assert_equal :log, Child.log
-  end
-
-end
-

data/test/test_mechanize_util.rb

@@ -1,144 +0,0 @@
-# coding: utf-8
-# frozen_string_literal: true
-
-require 'mechanize/test_case'
-
-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".dup.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'
-
-  def setup
-    super
-
-    @MU = Mechanize::Util
-    @result = "not set"
-  end
-
-  def test_from_native_charset
-    @result = @MU.from_native_charset(INPUTTED_VALUE, CONTENT_ENCODING)
-    assert_equal ENCODED_VALUE, @result
-  end
-
-  def test_from_native_charset_returns_nil_when_no_string
-    @result = @MU.from_native_charset(nil, CONTENT_ENCODING)
-    assert_nil @result
-  end
-
-  def test_from_native_charset_doesnot_convert_when_no_encoding
-    @result = @MU.from_native_charset(INPUTTED_VALUE, nil)
-    refute_equal ENCODED_VALUE, @result
-    assert_equal INPUTTED_VALUE, @result
-  end
-
-  def test_from_native_charset_doesnot_convert_when_not_nokogiri
-    parser = Mechanize.html_parser
-    Mechanize.html_parser = 'Another HTML Parser'
-
-    @result = @MU.from_native_charset(INPUTTED_VALUE, CONTENT_ENCODING)
-    refute_equal ENCODED_VALUE, @result
-    assert_equal INPUTTED_VALUE, @result
-  ensure
-    Mechanize.html_parser = parser
-  end
-
-  def test_from_native_charset_raises_error_with_bad_encoding
-    assert_raises(*ENCODING_ERRORS) do
-      @MU.from_native_charset(INPUTTED_VALUE, INVALID_ENCODING)
-    end
-  end
-
-  def test_from_native_charset_suppress_encoding_error_when_3rd_arg_is_true
-    @MU.from_native_charset(INPUTTED_VALUE, INVALID_ENCODING, true)
-
-    # HACK no assertion
-  end
-
-  def test_from_native_charset_doesnot_convert_when_encoding_error_raised_and_ignored
-    @result = @MU.from_native_charset(INPUTTED_VALUE, INVALID_ENCODING, true)
-
-    refute_equal ENCODED_VALUE, @result
-    assert_equal INPUTTED_VALUE, @result
-  end
-
-  def test_from_native_charset_logs_form_when_encoding_error_raised
-    sio = StringIO.new
-    log = Logger.new(sio)
-    log.level = Logger::DEBUG
-
-    assert_raises(*ENCODING_ERRORS) do
-      @MU.from_native_charset(INPUTTED_VALUE, INVALID_ENCODING, nil, log)
-    end
-
-    assert_match ERROR_LOG_MESSAGE, sio.string
-  end
-
-  def test_from_native_charset_logs_form_when_encoding_error_is_ignored
-    sio = StringIO.new
-    log = Logger.new(sio)
-    log.level = Logger::DEBUG
-
-    @MU.from_native_charset(INPUTTED_VALUE, INVALID_ENCODING, true, log)
-
-    assert_match ERROR_LOG_MESSAGE, sio.string
-  end
-
-  def test_self_html_unescape_entity
-    assert_equal '&', @MU::html_unescape('&')
-    assert_equal '&', @MU::html_unescape('&amp;')
-  end
-
-  def test_uri_escape
-    assert_equal "%25", @MU.uri_escape("%")
-    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
-

data/test/test_mechanize_xml_file.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-require 'mechanize/test_case'
-
-class TestMechanizeXmlFile < Mechanize::TestCase
-
-  def setup
-    super
-
-    uri = URI 'http://example.com/foo.xml'
-    @xml = Mechanize::XmlFile.new uri, nil, <<-XML
-      <languages>
-        <language>Ruby</language>
-        <language>Perl</language>
-      </languages>
-    XML
-  end
-
-  def test_xml
-    assert_kind_of Nokogiri::XML::Document, @xml.xml
-  end
-
-  def test_search
-    assert_equal ['Ruby', 'Perl'], @xml.search('language').map { |n| n.text }
-  end
-
-  def test_at
-    assert_equal 'Perl', @xml.at('//language[2]').text
-  end
-
-end