mechanize 0.4.7 → 0.5.0

data/test/tc_links.rb

@@ -8,23 +8,24 @@ require 'test_includes'
 class LinksMechTest < Test::Unit::TestCase
   include TestMethods
 
+  def setup
+    @agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+  end
+
   def test_find_meta
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/find_link.html")
+    page = @agent.get("http://localhost:#{PORT}/find_link.html")
     assert_equal(2, page.meta.length)
     assert_equal("http://www.drphil.com/", page.meta[0].href.downcase)
     assert_equal("http://www.upcase.com/", page.meta[1].href.downcase)
   end
 
   def test_find_link
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/find_link.html")
+    page = @agent.get("http://localhost:#{PORT}/find_link.html")
     assert_equal(15, page.links.length)
   end
 
   def test_alt_text
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/alt_text.html")
+    page = @agent.get("http://localhost:#{PORT}/alt_text.html")
     assert_equal(4, page.links.length)
     assert_equal(1, page.meta.length)
 

data/test/tc_mech.rb

@@ -9,63 +9,63 @@ require 'test_includes'
 class MechMethodsTest < Test::Unit::TestCase
   include TestMethods
 
+  def setup
+    @agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+  end
+
   def test_history
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
     0.upto(25) do |i|
-      assert_equal(i, agent.history.size)
-      page = agent.get("http://localhost:#{@port}/")
+      assert_equal(i, @agent.history.size)
+      page = @agent.get("http://localhost:#{PORT}/")
     end
-    page = agent.get("http://localhost:#{@port}/form_test.html")
+    page = @agent.get("http://localhost:#{PORT}/form_test.html")
 
-    assert_equal("http://localhost:#{@port}/form_test.html",
-      agent.history.last.uri.to_s)
-    assert_equal("http://localhost:#{@port}/",
-      agent.history[-2].uri.to_s)
+    assert_equal("http://localhost:#{PORT}/form_test.html",
+      @agent.history.last.uri.to_s)
+    assert_equal("http://localhost:#{PORT}/",
+      @agent.history[-2].uri.to_s)
 
-    assert_equal(true, agent.visited?("http://localhost:#{@port}/"))
-    assert_equal(true, agent.visited?("/form_test.html"))
-    assert_equal(false, agent.visited?("http://google.com/"))
-    assert_equal(true, agent.visited?(page.links.first))
+    assert_equal(true, @agent.visited?("http://localhost:#{PORT}/"))
+    assert_equal(true, @agent.visited?("/form_test.html"))
+    assert_equal(false, @agent.visited?("http://google.com/"))
+    assert_equal(true, @agent.visited?(page.links.first))
 
   end
 
   def test_max_history
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    agent.max_history = 10
+    @agent.max_history = 10
     0.upto(10) do |i|
-      assert_equal(i, agent.history.size)
-      page = agent.get("http://localhost:#{@port}/")
+      assert_equal(i, @agent.history.size)
+      page = @agent.get("http://localhost:#{PORT}/")
     end
     
     0.upto(10) do |i|
-      assert_equal(10, agent.history.size)
-      page = agent.get("http://localhost:#{@port}/")
+      assert_equal(10, @agent.history.size)
+      page = @agent.get("http://localhost:#{PORT}/")
     end
   end
 
   def test_back_button
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
     0.upto(5) do |i|
-      assert_equal(i, agent.history.size)
-      page = agent.get("http://localhost:#{@port}/")
+      assert_equal(i, @agent.history.size)
+      page = @agent.get("http://localhost:#{PORT}/")
     end
-    page = agent.get("http://localhost:#{@port}/form_test.html")
-
-    assert_equal("http://localhost:#{@port}/form_test.html",
-      agent.history.last.uri.to_s)
-    assert_equal("http://localhost:#{@port}/",
-      agent.history[-2].uri.to_s)
-
-    assert_equal(7, agent.history.size)
-    agent.back
-    assert_equal(6, agent.history.size)
-    assert_equal("http://localhost:#{@port}/",
-      agent.history.last.uri.to_s)
+    page = @agent.get("http://localhost:#{PORT}/form_test.html")
+
+    assert_equal("http://localhost:#{PORT}/form_test.html",
+      @agent.history.last.uri.to_s)
+    assert_equal("http://localhost:#{PORT}/",
+      @agent.history[-2].uri.to_s)
+
+    assert_equal(7, @agent.history.size)
+    @agent.back
+    assert_equal(6, @agent.history.size)
+    assert_equal("http://localhost:#{PORT}/",
+      @agent.history.last.uri.to_s)
   end
 
   def test_google
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/google.html")
+    page = @agent.get("http://localhost:#{PORT}/google.html")
     search = page.forms.find { |f| f.name == "f" }
     assert_not_nil(search)
     assert_not_nil(search.fields.name('q').first)
@@ -74,19 +74,17 @@ class MechMethodsTest < Test::Unit::TestCase
   end
 
   def test_click
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    agent.user_agent_alias = 'Mac Safari'
-    page = agent.get("http://localhost:#{@port}/frame_test.html")
+    @agent.user_agent_alias = 'Mac Safari'
+    page = @agent.get("http://localhost:#{PORT}/frame_test.html")
     link = page.links.text("Form Test").first
     assert_not_nil(link)
-    page = agent.click(link)
-    assert_equal("http://localhost:#{@port}/form_test.html",
-      agent.history.last.uri.to_s)
+    page = @agent.click(link)
+    assert_equal("http://localhost:#{PORT}/form_test.html",
+      @agent.history.last.uri.to_s)
   end
 
   def test_new_find
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/frame_test.html")
+    page = @agent.get("http://localhost:#{PORT}/frame_test.html")
     assert_equal(3, page.frames.size)
 
     find_orig = page.frames.find_all { |f| f.name == 'frame1' }
@@ -102,10 +100,9 @@ class MechMethodsTest < Test::Unit::TestCase
   end
 
   def test_get_file
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    page = agent.get("http://localhost:#{@port}/frame_test.html")
+    page = @agent.get("http://localhost:#{PORT}/frame_test.html")
     content_length = page.header['Content-Length']
-    page_as_string = agent.get_file("http://localhost:#{@port}/frame_test.html")
+    page_as_string = @agent.get_file("http://localhost:#{PORT}/frame_test.html")
     assert_equal(content_length.to_i, page_as_string.length.to_i)
   end
 end

data/test/tc_page.rb

@@ -0,0 +1,24 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'rubygems'
+require 'mechanize'
+require 'test_includes'
+
+class PageTest < Test::Unit::TestCase
+  include TestMethods
+
+  def setup
+    @agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+  end
+
+  def test_title
+    page = @agent.get("http://localhost:#{PORT}/file_upload.html")
+    assert_equal('File Upload Form', page.title)
+  end
+
+  def test_no_title
+    page = @agent.get("http://localhost:#{PORT}/no_title_test.html")
+    assert_equal(nil, page.title)
+  end
+end

data/test/tc_pluggable_parser.rb

@@ -0,0 +1,103 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'rubygems'
+require 'mechanize'
+require 'test_includes'
+
+class PluggableParserTest < Test::Unit::TestCase
+  include TestMethods
+
+  def setup
+    @agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+  end
+
+  def test_content_type_error
+    page = @agent.get("http://localhost:#{PORT}/bad_content_type")
+    page = WWW::Mechanize::Page.new(
+                                    page.uri, 
+                                    page.response, 
+                                    page.body,
+                                    page.code
+                                   )
+    assert_raise(WWW::Mechanize::ContentTypeError) {
+      page.root
+    }
+    begin
+      page.root
+    rescue WWW::Mechanize::ContentTypeError => ex
+      assert_equal('text/xml', ex.content_type)
+    end
+  end
+
+  def test_content_type
+    page = @agent.get("http://localhost:#{PORT}/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
+
+  def test_filter
+    @agent.pluggable_parser.html = Filter
+    page = @agent.get("http://localhost:#{PORT}/find_link.html")
+    assert_kind_of(Filter, page)
+    assert_equal(16, page.links.length)
+    assert_not_nil(page.links.text('Net::DAAP::Client').first)
+    assert_equal(1, page.links.text('Net::DAAP::Client').length)
+  end
+
+  def test_filter_hash
+    @agent.pluggable_parser['text/html'] = Filter
+    page = @agent.get("http://localhost:#{PORT}/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(16, page.links.length)
+    assert_not_nil(page.links.text('Net::DAAP::Client').first)
+    assert_equal(1, page.links.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 = Filter
+    page = @agent.get("http://localhost:#{PORT}/content_type_test?ct=application/pdf")
+    assert_kind_of(Class, @agent.pluggable_parser['application/pdf'])
+    assert_equal(Filter, @agent.pluggable_parser['application/pdf'])
+    assert_kind_of(Filter, page)
+  end
+
+  def test_content_type_csv
+    @agent.pluggable_parser.csv = Filter
+    page = @agent.get("http://localhost:#{PORT}/content_type_test?ct=text/csv")
+    assert_kind_of(Class, @agent.pluggable_parser['text/csv'])
+    assert_equal(Filter, @agent.pluggable_parser['text/csv'])
+    assert_kind_of(Filter, page)
+  end
+
+  def test_content_type_xml
+    @agent.pluggable_parser.xml = Filter
+    page = @agent.get("http://localhost:#{PORT}/content_type_test?ct=text/xml")
+    assert_kind_of(Class, @agent.pluggable_parser['text/xml'])
+    assert_equal(Filter, @agent.pluggable_parser['text/xml'])
+    assert_kind_of(Filter, page)
+  end
+end

data/test/tc_post_form.rb

@@ -0,0 +1,41 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'rubygems'
+require 'mechanize'
+require 'test_includes'
+
+class PostForm < Test::Unit::TestCase
+  include TestMethods
+
+  def setup
+    @agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+  end
+
+  def test_post_form
+    page = @agent.post("http://localhost:#{PORT}/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:#{PORT}/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/tc_proxy.rb

@@ -0,0 +1,25 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'rubygems'
+require 'mechanize'
+require 'test_includes'
+
+Thread.new {
+  require 'proxy'
+}
+
+class ProxyTest < Test::Unit::TestCase
+  include TestMethods
+
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_proxy
+    length = @agent.get("http://localhost:#{PORT}/find_link.html").body.length
+    @agent.set_proxy('127.0.0.1', PROXYPORT)
+    l2 = @agent.get("http://localhost:#{PORT}/find_link.html").body.length
+    assert_equal(length, l2)
+  end
+end

data/test/tc_response_code.rb

@@ -8,22 +8,25 @@ require 'test_includes'
 class ResponseCodeMechTest < Test::Unit::TestCase
   include TestMethods
 
+  def setup
+    @agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+  end
+
   def test_redirect
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    agent.get("http://localhost:#{@port}/response_code?code=301")
-    assert_equal("http://localhost:#{@port}/index.html",
-      agent.current_page.uri.to_s)
+    @agent.get("http://localhost:#{PORT}/response_code?code=301")
+    assert_equal("http://localhost:#{PORT}/index.html",
+      @agent.current_page.uri.to_s)
 
-    agent.get("http://localhost:#{@port}/response_code?code=302")
-    assert_equal("http://localhost:#{@port}/index.html",
-      agent.current_page.uri.to_s)
+    @agent.get("http://localhost:#{PORT}/response_code?code=302")
+    assert_equal("http://localhost:#{PORT}/index.html",
+      @agent.current_page.uri.to_s)
   end
 
   def test_error
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+    @agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
     begin
-      agent.get("http://localhost:#{@port}/response_code?code=500")
-    rescue WWW::ResponseCodeError => err
+      @agent.get("http://localhost:#{PORT}/response_code?code=500")
+    rescue WWW::Mechanize::ResponseCodeError => err
       assert_equal("500", err.response_code)
     end
   end

data/test/tc_save_file.rb

@@ -0,0 +1,25 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'rubygems'
+require 'mechanize'
+require 'test_includes'
+require 'fileutils'
+
+class TestSaveFile < Test::Unit::TestCase
+  include TestMethods
+
+  def setup
+    @agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+  end
+
+  def test_save_file
+    page = @agent.get('http://localhost:2000/form_no_action.html')
+    length = page.response['Content-Length']
+    page.save_as("test.html")
+    file_length = nil
+    File.open("test.html", "r") { |f| file_length = f.read.length }
+    FileUtils.rm("test.html")
+    assert_equal(length.to_i, file_length)
+  end
+end

data/test/tc_ssl_server.rb

@@ -0,0 +1,27 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'rubygems'
+require 'mechanize'
+require 'test_includes'
+
+class SSLServerTest < Test::Unit::TestCase
+  include TestMethods
+
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_ssl_request
+    non_ssl_page = @agent.get("http://localhost:#{PORT}/form_test.html")
+    ssl_page = @agent.get("https://localhost:#{SSLPORT}/form_test.html")
+    assert_equal(non_ssl_page.body.length, ssl_page.body.length)
+  end
+
+  def test_ssl_request_verify
+    non_ssl_page = @agent.get("http://localhost:#{PORT}/form_test.html")
+    @agent.ca_file = 'data/server.crt'
+    ssl_page = @agent.get("https://localhost:#{SSLPORT}/form_test.html")
+    assert_equal(non_ssl_page.body.length, ssl_page.body.length)
+  end
+end