tenderlove-mechanize 0.9.3.20090617085936

data/test/test_mechanize_file.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class MechanizeFileTest < Test::Unit::TestCase
+  def test_content_disposition
+    file = WWW::Mechanize::File.new(
+                                    URI.parse('http://localhost/foo'),
+           { 'content-disposition' => 'attachment; filename=genome.jpeg; modification-date="Wed, 12 Feb 1997 16:29:51 -0500"', }
+           )
+    assert_equal('genome.jpeg', file.filename)
+
+    file = WWW::Mechanize::File.new(
+                                    URI.parse('http://localhost/foo'),
+           { 'content-disposition' => 'filename=genome.jpeg; modification-date="Wed, 12 Feb 1997 16:29:51 -0500"', }
+           )
+    assert_equal('genome.jpeg', file.filename)
+
+    file = WWW::Mechanize::File.new(
+                                    URI.parse('http://localhost/foo'),
+           { 'content-disposition' => 'filename=genome.jpeg', }
+           )
+    assert_equal('genome.jpeg', file.filename)
+  end
+
+  def test_from_uri
+    file = WWW::Mechanize::File.new(
+                                    URI.parse('http://localhost/foo'),
+                                    {}
+           )
+    assert_equal('foo.html', file.filename)
+
+    file = WWW::Mechanize::File.new(
+                                    URI.parse('http://localhost/foo.jpg'),
+                                    {}
+           )
+    assert_equal('foo.jpg', file.filename)
+
+    file = WWW::Mechanize::File.new(
+                                    URI.parse('http://localhost/foo.jpg')
+           )
+    assert_equal('foo.jpg', file.filename)
+  end
+
+  def test_no_uri
+    file = WWW::Mechanize::File.new()
+    assert_equal('index.html', file.filename)
+  end
+end

data/test/test_meta.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class MetaTest < Test::Unit::TestCase
+  Meta = WWW::Mechanize::Page::Meta
+  
+  #
+  # CONTENT_REGEXP test
+  #
+  
+  def test_content_regexp
+    r = Meta::CONTENT_REGEXP
+    
+    assert r =~ "0; url=http://localhost:8080/path"
+    assert_equal "0", $1
+    assert_equal "http://localhost:8080/path", $3
+    
+    assert r =~ "100.001; url=http://localhost:8080/path"
+    assert_equal "100.001", $1
+    assert_equal "http://localhost:8080/path", $3
+    
+    assert r =~ "0; url='http://localhost:8080/path'"
+    assert_equal "0", $1
+    assert_equal "http://localhost:8080/path", $3
+    
+    assert r =~ "0; url=\"http://localhost:8080/path\""
+    assert_equal "0", $1
+    assert_equal "http://localhost:8080/path", $3
+    
+    assert r =~ "0; url="
+    assert_equal "0", $1
+    assert_equal "", $3
+    
+    assert r =~ "0"
+    assert_equal "0", $1
+    assert_equal nil, $3
+    
+    assert r =~ "   0;   "
+    assert_equal "0", $1
+    assert_equal nil, $3
+    
+    assert r =~ "0; UrL=http://localhost:8080/path"
+    assert_equal "0", $1
+    assert_equal "http://localhost:8080/path", $3
+  end
+  
+  #
+  # parse test
+  #
+  
+  def test_parse_documentation
+    uri = URI.parse('http://current.com/')
+  
+    assert_equal ['5', 'http://example.com/'], Meta.parse("5;url=http://example.com/", uri)
+    assert_equal ['5', 'http://current.com/'], Meta.parse("5;url=", uri) 
+    assert_equal ['5', 'http://current.com/'], Meta.parse("5", uri) 
+    assert_equal nil, Meta.parse("invalid content", uri)
+  end
+  
+  def test_parse_returns_nil_if_no_delay_and_url_can_be_parsed
+    uri = URI.parse('http://current.com/')
+    
+    assert_equal nil, Meta.parse("invalid content", uri)
+    assert_equal nil, Meta.parse("invalid content", uri) {|delay, url| 'not nil' }
+  end
+end

data/test/test_multi_select.rb

@@ -0,0 +1,106 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class MultiSelectTest < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_select_none
+    page = @agent.get("http://localhost/form_multi_select.html")
+    form = page.forms.first
+    form.field_with(:name => 'list').select_none
+    page = @agent.submit(form)
+    assert_equal(0, page.links.length)
+  end
+
+  def test_select_all
+    page = @agent.get("http://localhost/form_multi_select.html")
+    form = page.forms.first
+    form.field_with(:name => 'list').select_all
+    page = @agent.submit(form)
+    assert_equal(6, page.links.length)
+    assert_equal(1, page.links_with(:text => 'list:1').length)
+    assert_equal(1, page.links_with(:text => 'list:2').length)
+    assert_equal(1, page.links_with(:text => 'list:3').length)
+    assert_equal(1, page.links_with(:text => 'list:4').length)
+    assert_equal(1, page.links_with(:text => 'list:5').length)
+    assert_equal(1, page.links_with(:text => 'list:6').length)
+  end
+
+  def test_click_all
+    page = @agent.get("http://localhost/form_multi_select.html")
+    form = page.forms.first
+    form.field_with(:name => 'list').options.each { |o| o.click }
+    page = @agent.submit(form)
+    assert_equal(5, page.links.length)
+    assert_equal(1, page.links_with(:text => 'list:1').length)
+    assert_equal(1, page.links_with(:text => 'list:3').length)
+    assert_equal(1, page.links_with(:text => 'list:4').length)
+    assert_equal(1, page.links_with(:text => 'list:5').length)
+    assert_equal(1, page.links_with(:text => 'list:6').length)
+  end
+
+  def test_select_default
+    page = @agent.get("http://localhost/form_multi_select.html")
+    form = page.forms.first
+    page = @agent.submit(form)
+    assert_equal(1, page.links.length)
+    assert_equal(1, page.links_with(:text => 'list:2').length)
+  end
+
+  def test_select_one
+    page = @agent.get("http://localhost/form_multi_select.html")
+    form = page.forms.first
+    form.list = 'Aaron'
+    assert_equal(['Aaron'], form.list)
+    page = @agent.submit(form)
+    assert_equal(1, page.links.length)
+    assert_equal('list:Aaron', page.links.first.text)
+  end
+
+  def test_select_two
+    page = @agent.get("http://localhost/form_multi_select.html")
+    form = page.forms.first
+    form.list = ['1', 'Aaron']
+    page = @agent.submit(form)
+    assert_equal(2, page.links.length)
+    assert_equal(1, page.links_with(:text => 'list:1').length)
+    assert_equal(1, page.links_with(:text => 'list:Aaron').length)
+  end
+
+  def test_select_three
+    page = @agent.get("http://localhost/form_multi_select.html")
+    form = page.forms.first
+    form.list = ['1', '2', '3']
+    page = @agent.submit(form)
+    assert_equal(3, page.links.length)
+    assert_equal(1, page.links_with(:text => 'list:1').length)
+    assert_equal(1, page.links_with(:text => 'list:2').length)
+    assert_equal(1, page.links_with(:text => 'list:3').length)
+  end
+
+  def test_select_three_twice
+    page = @agent.get("http://localhost/form_multi_select.html")
+    form = page.forms.first
+    form.list = ['1', '2', '3']
+    form.list = ['1', '2', '3']
+    page = @agent.submit(form)
+    assert_equal(3, page.links.length)
+    assert_equal(1, page.links_with(:text => 'list:1').length)
+    assert_equal(1, page.links_with(:text => 'list:2').length)
+    assert_equal(1, page.links_with(:text => 'list:3').length)
+  end
+
+  def test_select_with_click
+    page = @agent.get("http://localhost/form_multi_select.html")
+    form = page.forms.first
+    form.list = ['1', 'Aaron']
+    form.field_with(:name => 'list').options[3].tick
+    assert_equal(['1', 'Aaron', '4'].sort, form.list.sort)
+    page = @agent.submit(form)
+    assert_equal(3, page.links.length)
+    assert_equal(1, page.links_with(:text => 'list:1').length)
+    assert_equal(1, page.links_with(:text => 'list:Aaron').length)
+    assert_equal(1, page.links_with(:text => 'list:4').length)
+  end
+end

data/test/test_no_attributes.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class TestNoAttributes < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_parse_no_attributes
+    assert_nothing_raised do
+      page = @agent.get('http://localhost/tc_no_attributes.html')
+    end
+  end
+end

data/test/test_option.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class OptionTest < Test::Unit::TestCase
+  class FakeAttribute < Hash
+    attr_reader :inner_text
+    def initialize(inner_text)
+      @inner_text = inner_text
+    end
+    alias :has_attribute? :has_key?
+    alias :attributes :keys
+  end
+
+  def test_option_missing_value
+    attribute = FakeAttribute.new('blah')
+    option = WWW::Mechanize::Form::Option.new(attribute, nil)
+    assert_equal('blah', option.value)
+  end
+end

data/test/test_page.rb

@@ -0,0 +1,119 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+require 'cgi'
+
+class TestPage < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_page_gets_charset_from_page
+    page = @agent.get("http://localhost/tc_charset.html")
+    assert_equal 'windows-1255', page.encoding
+  end
+
+  def test_double_semicolon
+    page = @agent.get("http://localhost/http_headers?content-disposition=#{CGI.escape('attachment;; filename=fooooo')}")
+    assert page.parser
+  end
+
+  def test_broken_charset
+    page = @agent.get("http://localhost/http_headers?content-type=#{CGI.escape('text/html; charset=akldsjfhaldjfksh')}")
+    assert page.parser
+  end
+
+  def test_mostly_broken_charset
+    page = @agent.get("http://localhost/http_headers?content-type=#{CGI.escape('text/html; charset=ISO_8859-1')}")
+    assert_equal 'ISO_8859-1', page.encoding
+  end
+
+  def test_another_mostly_broken_charset
+    page = @agent.get("http://localhost/http_headers?content-type=#{CGI.escape('text/html; charset=UTF8')}")
+    assert_equal 'UTF8', page.parser.encoding
+    assert_equal 'UTF8', page.encoding
+  end
+
+  def test_upper_case_content_type
+    page = @agent.get("http://localhost/http_headers?content-type=#{CGI.escape('text/HTML')}")
+    assert_instance_of WWW::Mechanize::Page, page
+    assert_equal 'text/HTML', page.content_type
+  end
+
+  def test_encoding_override_before_parser_initialized
+    # document has a bad encoding information - windows-1255
+    page = @agent.get("http://localhost/tc_bad_charset.html")
+    # encoding is wrong, so user wants to force ISO-8859-2
+    page.encoding = 'ISO-8859-2'
+    assert_equal 'ISO-8859-2', page.encoding
+  end
+
+  def test_encoding_override_after_parser_was_initialized
+    # document has a bad encoding information - windows-1255
+    page = @agent.get("http://localhost/tc_bad_charset.html")
+    page.parser
+    # autodetection sets encoding to windows-1255
+    assert_equal 'windows-1255', page.encoding
+    # encoding is wrong, so user wants to force ISO-8859-2
+    page.encoding = 'ISO-8859-2'
+    assert_equal 'ISO-8859-2', page.encoding
+  end
+
+  def test_page_gets_charset_sent_by_server
+    page = @agent.get("http://localhost/http_headers?content-type=#{CGI.escape('text/html; charset=UTF-8')}")
+    assert_equal 'UTF-8', page.encoding
+  end
+
+  def test_set_encoding
+    page = @agent.get("http://localhost/file_upload.html")
+    page.encoding = 'UTF-8'
+    assert_equal 'UTF-8', page.parser.encoding
+  end
+
+  def test_page_gets_yielded
+    pages = nil
+    @agent.get("http://localhost/file_upload.html") { |page|
+      pages = page
+    }
+    assert pages
+    assert_equal('File Upload Form', pages.title)
+  end
+
+  def test_title
+    page = @agent.get("http://localhost/file_upload.html")
+    assert_equal('File Upload Form', page.title)
+  end
+
+  def test_no_title
+    page = @agent.get("http://localhost/no_title_test.html")
+    assert_equal(nil, page.title)
+  end
+
+  def test_page_decoded_with_charset
+    page = WWW::Mechanize::Page.new(
+      URI.parse('http://tenderlovemaking.com/'),
+      { 'content-type' => 'text/html; charset=EUC-JP' },
+      '<html><body>hello</body></html>',
+      400,
+      @agent
+    )
+    assert_equal 'EUC-JP', page.parser.encoding
+  end
+
+  def test_find_form_with_hash
+    page  = @agent.get("http://localhost/tc_form_action.html")
+    form = page.form(:name => 'post_form1')
+    assert form
+    yielded = false
+    form = page.form(:name => 'post_form1') { |f|
+      yielded = true
+      assert f
+      assert_equal(form, f)
+    }
+    assert yielded
+
+    form_by_action = page.form(:action => '/form_post?a=b&b=c')
+    assert form_by_action
+    assert_equal(form, form_by_action)
+  end
+end
+

data/test/test_pluggable_parser.rb

@@ -0,0 +1,145 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class PluggableParserTest < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_content_type_error
+    page = @agent.get("http://localhost/bad_content_type")
+    assert_raise(WWW::Mechanize::ContentTypeError) {
+      page = WWW::Mechanize::Page.new(
+                                      page.uri, 
+                                      page.response, 
+                                      page.body,
+                                      page.code
+                                     )
+    }
+    begin
+      page = WWW::Mechanize::Page.new(
+                                      page.uri, 
+                                      page.response, 
+                                      page.body,
+                                      page.code
+                                     )
+    rescue WWW::Mechanize::ContentTypeError => ex
+      assert_equal('text/xml', ex.content_type)
+    end
+  end
+
+  def test_content_type
+    page = @agent.get("http://localhost/content_type_test")
+    assert_kind_of(WWW::Mechanize::Page, page)
+  end
+
+  class Filter < WWW::Mechanize::Page
+    def initialize(uri=nil, response=nil, body=nil, code=nil)
+      super(  uri,
+            response,
+            body.gsub(/<body>/, '<body><a href="http://daapclient.rubyforge.org">Net::DAAP::Client</a>'),
+            code
+           )
+    end
+  end
+
+  class FileFilter < WWW::Mechanize::File
+    def initialize(uri=nil, response=nil, body=nil, code=nil)
+      super(  uri,
+            response,
+            body.gsub(/<body>/, '<body><a href="http://daapclient.rubyforge.org">Net::DAAP::Client</a>'),
+            code
+           )
+    end
+  end
+
+  def test_filter
+    @agent.pluggable_parser.html = Filter
+    page = @agent.get("http://localhost/find_link.html")
+    assert_kind_of(Filter, page)
+    assert_equal(19, page.links.length)
+    assert_not_nil(page.link_with(:text => 'Net::DAAP::Client'))
+    assert_equal(1, page.links_with(:text => 'Net::DAAP::Client').length)
+  end
+
+  def test_filter_hash
+    @agent.pluggable_parser['text/html'] = Filter
+    page = @agent.get("http://localhost/find_link.html")
+    assert_kind_of(Class, @agent.pluggable_parser['text/html'])
+    assert_equal(Filter, @agent.pluggable_parser['text/html'])
+    assert_kind_of(Filter, page)
+    assert_equal(19, page.links.length)
+    assert_not_nil(page.link_with(:text => 'Net::DAAP::Client'))
+    assert_equal(1, page.links_with(:text => 'Net::DAAP::Client').length)
+  end
+
+  def test_file_saver
+    @agent.pluggable_parser.html = WWW::Mechanize::FileSaver
+    page = @agent.get('http://localhost:2000/form_no_action.html')
+    length = page.response['Content-Length']
+    file_length = nil
+    File.open("localhost/form_no_action.html", "r") { |f|
+      file_length = f.read.length
+    }
+    FileUtils.rm_rf("localhost")
+    assert_equal(length.to_i, file_length)
+  end
+
+  def test_content_type_pdf
+    @agent.pluggable_parser.pdf = FileFilter
+    page = @agent.get("http://localhost/content_type_test?ct=application/pdf")
+    assert_kind_of(Class, @agent.pluggable_parser['application/pdf'])
+    assert_equal(FileFilter, @agent.pluggable_parser['application/pdf'])
+    assert_kind_of(FileFilter, page)
+  end
+
+  def test_content_type_csv
+    @agent.pluggable_parser.csv = FileFilter
+    page = @agent.get("http://localhost/content_type_test?ct=text/csv")
+    assert_kind_of(Class, @agent.pluggable_parser['text/csv'])
+    assert_equal(FileFilter, @agent.pluggable_parser['text/csv'])
+    assert_kind_of(FileFilter, page)
+  end
+
+  def test_content_type_xml
+    @agent.pluggable_parser.xml = FileFilter
+    page = @agent.get("http://localhost/content_type_test?ct=text/xml")
+    assert_kind_of(Class, @agent.pluggable_parser['text/xml'])
+    assert_equal(FileFilter, @agent.pluggable_parser['text/xml'])
+    assert_kind_of(FileFilter, page)
+  end
+
+  def test_file_saver_no_path
+    url = URI::HTTP.new('http', nil, 'example.com', nil, nil, '', nil, nil, nil)
+    fs = WWW::Mechanize::FileSaver.new(url, nil, 'hello world', 200)
+    assert_equal('example.com/index.html', fs.filename)
+    FileUtils.rm_rf('example.com')
+  end
+
+  def test_file_saver_slash
+    url = URI::HTTP.new('http', nil, 'example.com', nil, nil, '/', nil, nil, nil)
+    fs = WWW::Mechanize::FileSaver.new(url, nil, 'hello world', 200)
+    assert_equal('example.com/index.html', fs.filename)
+    FileUtils.rm_rf('example.com')
+  end
+
+  def test_file_saver_slash_file
+    url = URI::HTTP.new('http', nil, 'example.com', nil, nil, '/foo.html', nil, nil, nil)
+    fs = WWW::Mechanize::FileSaver.new(url, nil, 'hello world', 200)
+    assert_equal('example.com/foo.html', fs.filename)
+    FileUtils.rm_rf('example.com')
+  end
+
+  def test_file_saver_long_path_no_file
+    url = URI::HTTP.new('http', nil, 'example.com', nil, nil, '/one/two/', nil, nil, nil)
+    fs = WWW::Mechanize::FileSaver.new(url, nil, 'hello world', 200)
+    assert_equal('example.com/one/two/index.html', fs.filename)
+    FileUtils.rm_rf('example.com')
+  end
+
+  def test_file_saver_long_path
+    url = URI::HTTP.new('http', nil, 'example.com', nil, nil, '/one/two/foo.html', nil, nil, nil)
+    fs = WWW::Mechanize::FileSaver.new(url, nil, 'hello world', 200)
+    assert_equal('example.com/one/two/foo.html', fs.filename)
+    FileUtils.rm_rf('example.com')
+  end
+end

data/test/test_post_form.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class PostForm < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_post_form
+    page = @agent.post("http://localhost/form_post",
+                        'gender' => 'female'
+                      )
+    assert_not_nil(
+      page.links.find { |l| l.text == "gender:female" },
+      "gender field missing"
+    )
+  end
+
+  def test_post_form_multival
+    page = @agent.post("http://localhost/form_post",
+                       [ ['gender', 'female'],
+                         ['gender', 'male']
+                       ]
+                      )
+    assert_not_nil(
+      page.links.find { |l| l.text == "gender:female" },
+      "gender field missing"
+    )
+    assert_not_nil(
+      page.links.find { |l| l.text == "gender:male" },
+      "gender field missing"
+    )
+    assert_equal(2, page.links.length)
+  end
+end

data/test/test_pretty_print.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class TestPrettyPrint < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+  
+  def test_pretty_print
+    @agent.get("http://localhost/tc_pretty_print.html")
+    pretty_string = @agent.pretty_print_inspect
+    assert_match("{title \"tc_pretty_print.html\"}", pretty_string)
+    assert_match(/\{frames[^"]*"http:\/\/meme/, pretty_string)
+    assert_match(/\{iframes[^"]*"http:\/\/meme/, pretty_string)
+    assert_match(
+     "{links #<WWW::Mechanize::Page::Link \"Google\" \"http://google.com/\">}",
+     pretty_string
+                )
+    assert_match("form1", pretty_string)
+    assert_match("POST", pretty_string)
+    assert_match("{file_uploads}", pretty_string)
+  end
+end

data/test/test_radiobutton.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class TestRadioButtons < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+    @page  = @agent.get("http://localhost/tc_radiobuttons.html")
+  end
+
+  def test_select_all
+    form = @page.forms.first
+    form.radiobuttons_with(:name => 'color').each do |b|
+      b.check
+    end
+    form.radiobutton_with(:name => 'color', :value => 'green').check
+
+    assert_equal(true, form.radiobutton_with( :name => 'color',
+                                              :value => 'green').checked)
+
+    %w{ red blue yellow brown }.each do |button_value|
+      assert_equal(false, form.radiobutton_with(  :name => 'color',
+                                                  :value => button_value
+                                               ).checked)
+    end
+  end
+
+  def test_unselect_all
+    form = @page.forms.first
+    form.radiobuttons_with(:name => 'color').each do |b|
+      b.uncheck
+    end
+    %w{ green red blue yellow brown }.each do |button_value|
+      assert_equal(false, form.radiobutton_with(  :name => 'color',
+                                                  :value => button_value
+                                               ).checked)
+    end
+  end
+
+  def test_click_one
+    form = @page.forms.first
+    form.radiobutton_with(:name => 'color', :value => 'green').click
+
+    assert form.radiobutton_with(:name => 'color', :value => 'green').checked
+
+    %w{ red blue yellow brown }.each do |button_value|
+      assert_equal(false, form.radiobutton_with(  :name => 'color',
+                                                  :value => button_value
+                                               ).checked)
+    end
+  end
+
+  def test_click_twice
+    form = @page.forms.first
+    form.radiobutton_with(:name => 'color', :value => 'green').click
+    assert form.radiobutton_with(:name => 'color', :value => 'green').checked
+
+    form.radiobutton_with(:name => 'color', :value => 'green').click
+    %w{ green red blue yellow brown }.each do |button_value|
+      assert_equal(false, form.radiobutton_with(  :name => 'color',
+                                                  :value => button_value
+                                               ).checked)
+    end
+  end
+
+  def test_click_all
+    form = @page.forms.first
+    form.radiobuttons_with(:name => 'color').each do |button|
+      button.click
+    end
+    c = form.radiobuttons_with(:name => 'color').inject(0) do |m,button|
+      m += 1 if button.checked
+      m
+    end
+    assert_equal 1, c, 'Only one radio button should be checked'
+  end
+end