mechanize 2.0.pre.1 → 2.0.pre.2

data/test/{test_forms.rb → test_mechanize_form.rb}

@@ -1,10 +1,42 @@
 require "helper"
 
-class FormsMechTest < Test::Unit::TestCase
+class TestMechanizeForm < Test::Unit::TestCase
+
   def setup
     @agent = Mechanize.new
   end
 
+  def test_build_query_blank_form
+    page = @agent.get('http://localhost/tc_blank_form.html')
+    form = page.forms.first
+    query = form.build_query
+    assert(query.length > 0)
+    assert query.all? { |x| x[1] == '' }
+  end
+
+  def test_field_with
+    page = @agent.get("http://localhost/google.html")
+    search = page.forms.find { |f| f.name == "f" }
+    assert_not_nil(search)
+    assert_not_nil(search.field_with(:name => 'q'))
+    assert_not_nil(search.field_with(:name => 'hl'))
+    assert_not_nil(search.fields.find { |f| f.name == 'ie' })
+  end
+
+  def test_parse_textarea
+    form = Nokogiri::HTML <<-FORM
+<form>
+<textarea name="t">hi</textarea>
+</form>
+    FORM
+
+    form = Mechanize::Form.new form, @agent
+    textarea = form.fields.first
+
+    assert_kind_of Mechanize::Form::Textarea, textarea
+    assert_equal 'hi', textarea.value
+  end
+
   def test_post_with_rails_3_encoding_hack
     page = @agent.get("http://localhost/rails_3_encoding_hack_form_test.html")
     form = page.forms.first
@@ -25,6 +57,18 @@ class FormsMechTest < Test::Unit::TestCase
     assert_match('/form_no_action.html?first=Aaron', page.uri.to_s)
   end
 
+  def test_submit_first_field_wins
+    page = @agent.get('http://localhost/tc_field_precedence.html')
+    form = page.forms.first
+
+    assert !form.checkboxes.empty?
+    assert_equal "1", form.checkboxes.first.value
+
+    submitted = form.submit
+
+    assert_equal 'ticky=1&ticky=0', submitted.parser.at('#query').text
+  end
+
   def test_submit_takes_arbirary_headers
     page = @agent.get('http://localhost:2000/form_no_action.html')
     assert form = page.forms.first

data/test/test_mechanize_form_check_box.rb

@@ -0,0 +1,37 @@
+require 'helper'
+
+class TestMechanizeFormCheckBox < Test::Unit::TestCase
+
+  def setup
+    @agent = Mechanize.new
+    @page = @agent.get('http://localhost/tc_checkboxes.html')
+  end
+
+  def test_check
+    form = @page.forms.first
+
+    form.checkbox_with(:name => 'green').check
+
+    assert(form.checkbox_with(:name => 'green').checked)
+
+    %w{ red blue yellow brown }.each do |color|
+      assert_equal(false, form.checkbox_with(:name => color).checked)
+    end
+  end
+
+  def test_uncheck
+    form = @page.forms.first
+
+    checkbox = form.checkbox_with(:name => 'green')
+
+    checkbox.check
+
+    assert form.checkbox_with(:name => 'green').checked
+
+    checkbox.uncheck
+
+    assert !form.checkbox_with(:name => 'green').checked
+  end
+
+end
+

data/test/test_mechanize_form_encoding.rb

@@ -0,0 +1,118 @@
+# coding: utf-8
+require "helper"
+
+class TestMechanizeFormEncoding < Test::Unit::TestCase
+
+  # See also: tests of Util.from_native_charset
+  # Encoding test should do with non-utf-8 characters
+
+  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)
+  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_LOG_MESSAGE = /INFO -- : form encoding: Shift_JIS/
+  INVALID_ENCODING = 'UTF-eight'
+
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def set_form_with_encoding(enc)
+    page = @agent.get("http://localhost/form_set_fields.html")
+    form = page.forms.first
+    form.encoding = enc
+    form['first_name'] = INPUTTED_VALUE
+    form
+  end
+
+
+  def test_form_encoding_returns_accept_charset
+    page = @agent.get("http://localhost/rails_3_encoding_hack_form_test.html")
+    form = page.forms.first
+    accept_charset = form.form_node['accept-charset']
+
+    assert accept_charset
+    assert_equal accept_charset, form.encoding
+    assert_not_equal page.encoding, form.encoding
+  end
+
+  def test_form_encoding_returns_page_encoding_when_no_accept_charset
+    page = @agent.get("http://localhost/form_set_fields.html")
+    form = page.forms.first
+    accept_charset = form.form_node['accept-charset']
+
+    assert_nil accept_charset
+    assert_not_equal accept_charset, form.encoding
+    assert_equal page.encoding, form.encoding
+  end
+
+  def test_form_encoding_equals_sets_new_encoding
+    page = @agent.get("http://localhost/form_set_fields.html")
+    form = page.forms.first
+
+    assert_not_equal CONTENT_ENCODING, form.encoding
+
+    form.encoding = CONTENT_ENCODING
+
+    assert_equal CONTENT_ENCODING, form.encoding
+  end
+
+  def test_form_encoding_returns_nil_when_no_page_in_initialize
+    # this sequence is seen at Mechanize#post(url, query_hash)
+
+    node = {}
+    # Create a fake form
+    class << node
+      def search(*args); []; end
+    end
+    node['method'] = 'POST'
+    node['enctype'] = 'application/x-www-form-urlencoded'
+    form = Mechanize::Form.new(node)
+
+    assert_equal nil, form.encoding
+  end
+
+
+  def test_post_form_with_form_encoding
+    form = set_form_with_encoding CONTENT_ENCODING
+    form.submit
+
+    # we can not use "links.find{|l| l.text == 'key:val'}" assertion here
+    # because the link text encoding is always UTF-8 regaredless of html encoding
+    assert EXPECTED_QUERY, @agent.page.at('div#query').inner_text
+  end
+
+  def test_post_form_with_problematic_encoding
+    form = set_form_with_encoding INVALID_ENCODING
+
+    assert_raise(*ENCODING_ERRORS){ form.submit }
+  end
+
+  def test_form_ignore_encoding_error_is_true
+    form = set_form_with_encoding INVALID_ENCODING
+    form.ignore_encoding_error = true
+
+    assert_nothing_raised(*ENCODING_ERRORS){ form.submit }
+  end
+
+  def test_post_form_logs_form_encoding
+    sio = StringIO.new
+    @agent.log = Logger.new(sio)
+    @agent.log.level = Logger::INFO
+
+    form = set_form_with_encoding CONTENT_ENCODING
+    form.submit
+
+    assert_match ENCODING_LOG_MESSAGE, sio.string
+
+    @agent.log = nil
+  end
+end

data/test/{test_field_precedence.rb → test_mechanize_form_field.rb}

@@ -1,22 +1,8 @@
 require 'helper'
 
-class TestFieldPrecedence < Test::Unit::TestCase
-  def setup
-    @agent = Mechanize.new
-    @page = @agent.get('http://localhost/tc_field_precedence.html')
-  end
-
-  def test_first_field_wins
-    form = @page.forms.first
-    assert !form.checkboxes.empty?
-    assert_equal "1", form.checkboxes.first.value
+class TestMechanizeFormField < Test::Unit::TestCase
 
-    submitted = form.submit
-
-    assert_equal 'ticky=1&ticky=0', submitted.parser.at('#query').text
-  end
-
-  def test_field_sort
+  def test_field_spaceship
     doc = Nokogiri::HTML::Document.new
     node = doc.create_element('input')
     node['name'] = 'foo'
@@ -30,4 +16,6 @@ class TestFieldPrecedence < Test::Unit::TestCase
     assert_equal [a, b], [b, a].sort
     assert_equal [b, c].sort, [b, c].sort
   end
+
 end
+

data/test/test_mechanize_page.rb

@@ -40,15 +40,45 @@ class TestMechanizePage < Test::Unit::TestCase
 
   def setup
     @agent = Mechanize.new
-    @uri = URI.parse 'http://example'
+    @uri = URI('http://example')
     @res = { 'content-type' => 'text/html' }
     @body = '<title>hi</title>'
   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, @agent
   end
 
+  def test_initialize_content_type
+    assert Mechanize::Page.new nil, 'content-type' => 'application/xhtml+xml'
+    assert Mechanize::Page.new nil, 'content-type' => 'text/html'
+
+    e = assert_raises Mechanize::ContentTypeError do
+      Mechanize::Page.new nil, 'content-type' => 'text/plain'
+    end
+
+    assert_equal 'text/plain', e.content_type
+  end
+
+  def test_canonical_uri
+    page = @agent.get("http://localhost/canonical_uri.html")
+    assert_equal(URI("http://localhost/canonical_uri"), page.canonical_uri)
+
+    page = @agent.get("http://localhost/file_upload.html")
+    assert_equal(nil, page.canonical_uri)
+  end
+
+  def test_canonical_uri_unescaped
+    page = util_page <<-BODY
+<head>
+  <link rel="canonical" href="http://example/white space"/>
+</head>
+    BODY
+
+    assert_equal @uri + '/white%20space', page.canonical_uri
+  end
+
   def test_charset
     charset = util_page.charset 'text/html;charset=UTF-8'
 
@@ -85,11 +115,27 @@ class TestMechanizePage < Test::Unit::TestCase
     assert_equal 'SHIFT_JIS', page.encoding
   end
 
+  def test_encoding_charset_bad
+    page = util_page "<title>#{UTF8_TITLE}</title>"
+    page.encodings.replace %w[
+      UTF-8
+      Shift_JIS
+    ]
+
+    assert_equal [], page.parser.errors
+
+    assert_equal 'UTF-8', page.encoding
+  end
+
   def test_encoding_equals
     page = util_page
+    page.meta
+    assert page.instance_variable_get(:@meta)
 
     page.encoding = 'UTF-8'
 
+    assert_nil page.instance_variable_get(:@meta)
+
     assert_equal 'UTF-8', page.encoding
     assert_equal 'UTF-8', page.parser.encoding
   end
@@ -122,6 +168,19 @@ class TestMechanizePage < Test::Unit::TestCase
     assert_equal 'ISO-8859-2', page.parser.encoding
   end
 
+  def test_frames_with
+    page = @agent.get("http://localhost/frame_test.html")
+    assert_equal(3, page.frames.size)
+
+    find_orig = page.frames.find_all { |f| f.name == 'frame1' }
+
+    find1 = page.frames_with(:name => 'frame1')
+
+    find_orig.zip(find1).each { |a,b|
+      assert_equal(a, b)
+    }
+  end
+
   def test_title
     page = util_page
 

data/test/test_mechanize_redirect_not_get_or_head_error.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+class TestMechanizeRedirectNotGetOrHead < Test::Unit::TestCase
+
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_to_s
+    page = MechTestHelper.fake_page(@agent)
+
+    error = Mechanize::RedirectNotGetOrHeadError.new(page, :put)
+
+    assert_match(/ PUT /, error.to_s)
+  end
+
+end
+

data/test/test_mechanize_subclass.rb

@@ -0,0 +1,22 @@
+require "helper"
+
+class TestMechanizeSubclass < Test::Unit::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,7 +1,92 @@
-require "helper"
+# coding: utf-8
+require 'helper'
 
 class TestMechanizeUtil < Test::Unit::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
+
+  INVALID_ENCODING = 'UTF-eight'
+
+  def setup
+    @result = "non_nil"
+  end
+
   def test_from_native_charset
-    assert_equal 'foo', Mechanize::Util.from_native_charset('foo', nil)
+    @result = Mechanize::Util.from_native_charset(INPUTTED_VALUE, CONTENT_ENCODING)
+    assert_equal ENCODED_VALUE, @result
+  end
+
+  def test_from_native_charset_returns_nil_when_no_string
+    @result = Mechanize::Util.from_native_charset(nil, CONTENT_ENCODING)
+    assert_equal nil, @result
+  end
+
+  def test_from_native_charset_doesnot_convert_when_no_encoding
+    @result = Mechanize::Util.from_native_charset(INPUTTED_VALUE, nil)
+    assert_not_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 = Mechanize::Util.from_native_charset(INPUTTED_VALUE, CONTENT_ENCODING)
+    assert_not_equal ENCODED_VALUE, @result
+    assert_equal INPUTTED_VALUE, @result
+
+    Mechanize.html_parser = parser
+  end
+
+  def test_from_native_charset_raises_error_with_bad_encoding
+    assert_raise(*ENCODING_ERRORS){
+      @result = Mechanize::Util.from_native_charset(INPUTTED_VALUE, INVALID_ENCODING)
+    }
+  end
+
+  def test_from_native_charset_suppress_encoding_error_when_3rd_arg_is_true
+    assert_nothing_raised(*ENCODING_ERRORS){
+      @result = Mechanize::Util.from_native_charset(INPUTTED_VALUE, INVALID_ENCODING, true)
+    }
+  end
+
+  def test_from_native_charset_doesnot_convert_when_encoding_error_raised_and_ignored
+    @result = Mechanize::Util.from_native_charset(INPUTTED_VALUE, INVALID_ENCODING, true)
+
+    assert_not_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_raise(*ENCODING_ERRORS){
+      @result = Mechanize::Util.from_native_charset(INPUTTED_VALUE, INVALID_ENCODING, nil, log)
+    }
+    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
+
+    assert_nothing_raised(*ENCODING_ERRORS){
+      @result = Mechanize::Util.from_native_charset(INPUTTED_VALUE, INVALID_ENCODING, true, log)
+    }
+    assert_match ERROR_LOG_MESSAGE, sio.string
   end
 end