mechanize 0.4.7 → 0.5.0

data/test/servlets.rb

@@ -9,6 +9,14 @@ class BadContentTypeTest < WEBrick::HTTPServlet::AbstractServlet
   end
 end
 
+class ContentTypeTest < WEBrick::HTTPServlet::AbstractServlet
+  def do_GET(req, res)
+    ct = req.query['ct'] || "text/html; charset=utf-8"
+    res['Content-Type'] = ct
+    res.body = "Hello World"
+  end
+end
+
 class FileUploadTest < WEBrick::HTTPServlet::AbstractServlet
   def do_POST(req, res)
     res.body = req.body

data/test/ssl_server.rb

@@ -0,0 +1,49 @@
+require 'webrick'
+require 'webrick/https'
+require 'servlets'
+require 'logger'
+
+base_dir = FileTest.exists?(Dir::pwd + '/test') ? Dir::pwd + '/test' : Dir::pwd
+
+s = WEBrick::HTTPServer.new(
+  :Port           => 2002,
+  :DocumentRoot   => base_dir + "/htdocs",
+  :SSLEnable      => true,
+  :SSLVerifyClient  => OpenSSL::SSL::VERIFY_NONE,
+  :SSLCertificate => OpenSSL::X509::Certificate.new(
+                                  File.read("data/server.crt")
+                       ),
+  :SSLPrivateKey    => OpenSSL::PKey::RSA.new(
+                                  File.read("data/server.pem")
+                       ),
+  :Logger         => Logger.new(nil),
+  :AccessLog      => Logger.new(nil)
+)
+s.mount("/one_cookie", OneCookieTest)
+s.mount("/one_cookie_no_space", OneCookieNoSpacesTest)
+s.mount("/many_cookies", ManyCookiesTest)
+s.mount("/many_cookies_as_string", ManyCookiesAsStringTest)
+s.mount("/send_cookies", SendCookiesTest)
+s.mount("/form_post", FormTest)
+s.mount("/form post", FormTest)
+s.mount("/response_code", ResponseCodeTest)
+s.mount("/file_upload", FileUploadTest)
+s.mount("/bad_content_type", BadContentTypeTest)
+s.mount("/content_type_test", ContentTypeTest)
+
+htpasswd = WEBrick::HTTPAuth::Htpasswd.new(base_dir + '/data/htpasswd')
+auth = WEBrick::HTTPAuth::BasicAuth.new(
+  :UserDB => htpasswd,
+  :Realm  => 'mechanize',
+  :Logger         => Logger.new(nil),
+  :AccessLog      => Logger.new(nil)
+)
+s.mount_proc('/htpasswd_auth') { |req, res|
+  auth.authenticate(req, res)
+  res.body = "You are authenticated"
+}
+
+trap("INT") { s.stop }
+
+s.start
+

data/test/tc_authenticate.rb

@@ -8,18 +8,20 @@ require 'test_includes'
 class BasicAuthTest < Test::Unit::TestCase
   include TestMethods
 
+  def setup
+    @agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+  end
+
   def test_auth_success
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
-    agent.basic_auth('mech', 'password')
-    page = agent.get("http://localhost:#{@port}/htpasswd_auth")
+    @agent.basic_auth('mech', 'password')
+    page = @agent.get("http://localhost:#{PORT}/htpasswd_auth")
     assert_equal('You are authenticated', page.body)
   end
 
   def test_auth_failure
-    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
     begin
-      page = agent.get("http://localhost:#{@port}/htpasswd_auth")
-    rescue WWW::ResponseCodeError => e
+      page = @agent.get("http://localhost:#{PORT}/htpasswd_auth")
+    rescue WWW::Mechanize::ResponseCodeError => e
       assert_equal("401", e.response_code)
     end
   end

data/test/tc_cookie_class.rb

@@ -26,7 +26,7 @@ class CookieClassTest < Test::Unit::TestCase
   def test_parse_dates
     url = URI.parse('http://localhost/')
 
-    yesterday = DateTime.now - 1
+    yesterday = Time.now - 86400
 
     dates = [ "14 Apr 89 03:20:12",
               "14 Apr 89 03:20 GMT",
@@ -41,18 +41,33 @@ class CookieClassTest < Test::Unit::TestCase
               "22-AUG-1993 12:59 PM",
               #"Friday, August 04, 1995 3:54 PM",
               "06/21/95 04:24:34 PM",
-              "20/06/95 21:07",
+              #"20/06/95 21:07",
               "95-06-08 19:32:48 EDT",
     ]
 
     dates.each do |date|
       cookie = "PREF=1; expires=#{date}"
-      WWW::Cookie.parse(url, cookie) { |cookie|
+      WWW::Mechanize::Cookie.parse(url, cookie) { |cookie|
         assert_equal(true, cookie.expires < yesterday)
       }
     end
   end
 
+  def test_parse_date_fail
+    url = URI.parse('http://localhost/')
+
+    dates = [ 
+              "20/06/95 21:07",
+    ]
+
+    dates.each do |date|
+      cookie = "PREF=1; expires=#{date}"
+      WWW::Mechanize::Cookie.parse(url, cookie) { |cookie|
+        assert_equal(true, cookie.expires > (Time.now - 86400))
+      }
+    end
+  end
+
   def test_parse_valid_cookie
     url = URI.parse('http://rubyforge.org/')
     cookie_params = {}
@@ -62,8 +77,7 @@ class CookieClassTest < Test::Unit::TestCase
     cookie_params['httponly']  = 'HttpOnly'
     cookie_value = '12345%7D=ASDFWEE345%3DASda'
 
-    expires = DateTime.strptime('Sun, 27-Sep-2037 00:00:00 GMT',
-              '%a, %d-%b-%Y %T %Z')
+    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
     
     cookie_params.keys.combine.each do |c|
       cookie_text = "#{cookie_value}; "
@@ -75,7 +89,7 @@ class CookieClassTest < Test::Unit::TestCase
         end
       end
       cookie = nil
-      WWW::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
+      WWW::Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
       assert_not_nil(cookie)
       assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
       assert_equal('/', cookie.path)
@@ -100,8 +114,7 @@ class CookieClassTest < Test::Unit::TestCase
     cookie_params['httponly']  = 'HttpOnly'
     cookie_value = '12345%7D=ASDFWEE345%3DASda'
 
-    expires = DateTime.strptime('Sun, 27-Sep-2037 00:00:00 GMT',
-              '%a, %d-%b-%Y %T %Z')
+    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
     
     cookie_params.keys.combine.each do |c|
       next if c.find { |k| k == 'path' }
@@ -114,7 +127,7 @@ class CookieClassTest < Test::Unit::TestCase
         end
       end
       cookie = nil
-      WWW::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
+      WWW::Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
       assert_not_nil(cookie)
       assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
       assert_equal('rubyforge.org', cookie.domain)
@@ -139,8 +152,7 @@ class CookieClassTest < Test::Unit::TestCase
     cookie_params['secure']    = 'secure'
     cookie_value = '12345%7D=ASDFWEE345%3DASda'
 
-    expires = DateTime.strptime('Sun, 27-Sep-2037 00:00:00 GMT',
-              '%a, %d-%b-%Y %T %Z')
+    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
     
     cookie_params.keys.combine.each do |c|
       next unless c.find { |k| k == 'secure' }
@@ -153,7 +165,7 @@ class CookieClassTest < Test::Unit::TestCase
         end
       end
       cookie = nil
-      WWW::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
+      WWW::Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
       assert_not_nil(cookie)
       assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
       assert_equal('rubyforge.org', cookie.domain)
@@ -179,8 +191,7 @@ class CookieClassTest < Test::Unit::TestCase
     cookie_params['httponly']  = 'HttpOnly'
     cookie_value = '12345%7D=ASDFWEE345%3DASda'
 
-    expires = DateTime.strptime('Sun, 27-Sep-2037 00:00:00 GMT',
-              '%a, %d-%b-%Y %T %Z')
+    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
     
     cookie_params.keys.combine.each do |c|
       next if c.find { |k| k == 'domain' }
@@ -193,7 +204,7 @@ class CookieClassTest < Test::Unit::TestCase
         end
       end
       cookie = nil
-      WWW::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
+      WWW::Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
       assert_not_nil(cookie)
       assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
       assert_equal('/', cookie.path)
@@ -218,8 +229,7 @@ class CookieClassTest < Test::Unit::TestCase
     cookie_params['httponly']  = 'HttpOnly'
     cookie_value = '12345%7D=ASDFWEE345%3DASda'
 
-    expires = DateTime.strptime('Sun, 27-Sep-2037 00:00:00 GMT',
-              '%a, %d-%b-%Y %T %Z')
+    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
     
     cookie_params.keys.combine.each do |c|
       cookie_text = "#{cookie_value};"
@@ -231,7 +241,7 @@ class CookieClassTest < Test::Unit::TestCase
         end
       end
       cookie = nil
-      WWW::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
+      WWW::Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
       assert_not_nil(cookie)
       assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
       assert_equal('/', cookie.path)

data/test/tc_cookie_jar.rb

@@ -4,27 +4,28 @@ require 'test/unit'
 require 'mechanize/cookie'
 require 'uri'
 require 'test_includes'
+require 'fileutils'
 
 class CookieJarTest < Test::Unit::TestCase
   def test_add_future_cookies
     values = {  :name     => 'Foo',
                 :value    => 'Bar',
                 :path     => '/',
-                :expires  => DateTime.now + 10,
+                :expires  => Time.now + (10 * 86400),
                 :domain   => 'rubyforge.org'
              }
     url = URI.parse('http://rubyforge.org/')
 
-    jar = WWW::CookieJar.new
+    jar = WWW::Mechanize::CookieJar.new
     assert_equal(0, jar.cookies(url).length)
 
     # Add one cookie with an expiration date in the future
-    cookie = WWW::Cookie.new(values)
+    cookie = WWW::Mechanize::Cookie.new(values)
     jar.add(cookie)
     assert_equal(1, jar.cookies(url).length)
 
     # Add the same cookie, and we should still only have one
-    jar.add(WWW::Cookie.new(values))
+    jar.add(WWW::Mechanize::Cookie.new(values))
     assert_equal(1, jar.cookies(url).length)
 
     # Make sure we can get the cookie from different paths
@@ -38,21 +39,21 @@ class CookieJarTest < Test::Unit::TestCase
     values = {  :name     => 'Foo',
                 :value    => 'Bar',
                 :path     => '/',
-                :expires  => DateTime.now + 10,
+                :expires  => Time.now + (10 * 86400),
                 :domain   => 'rubyforge.org'
              }
     url = URI.parse('http://rubyforge.org/')
 
-    jar = WWW::CookieJar.new
+    jar = WWW::Mechanize::CookieJar.new
     assert_equal(0, jar.cookies(url).length)
 
     # Add one cookie with an expiration date in the future
-    cookie = WWW::Cookie.new(values)
+    cookie = WWW::Mechanize::Cookie.new(values)
     jar.add(cookie)
     assert_equal(1, jar.cookies(url).length)
 
     # Add the same cookie, and we should still only have one
-    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz' )))
+    jar.add(WWW::Mechanize::Cookie.new(values.merge( :name => 'Baz' )))
     assert_equal(2, jar.cookies(url).length)
 
     # Make sure we can get the cookie from different paths
@@ -62,37 +63,87 @@ class CookieJarTest < Test::Unit::TestCase
     assert_equal(0, jar.cookies(URI.parse('http://google.com/')).length)
   end
 
+  def test_clear_cookies
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => Time.now + (10 * 86400),
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::Mechanize::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = WWW::Mechanize::Cookie.new(values)
+    jar.add(cookie)
+    jar.add(WWW::Mechanize::Cookie.new(values.merge( :name => 'Baz' )))
+    assert_equal(2, jar.cookies(url).length)
+
+    jar.clear!
+
+    assert_equal(0, jar.cookies(url).length)
+  end
+
+  def test_save_cookies
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => Time.now + (10 * 86400),
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::Mechanize::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = WWW::Mechanize::Cookie.new(values)
+    jar.add(cookie)
+    jar.add(WWW::Mechanize::Cookie.new(values.merge( :name => 'Baz' )))
+    assert_equal(2, jar.cookies(url).length)
+
+    jar.save_as("cookies.yml")
+    jar.clear!
+    assert_equal(0, jar.cookies(url).length)
+
+    jar.load("cookies.yml")
+    assert_equal(2, jar.cookies(url).length)
+    FileUtils.rm("cookies.yml")
+  end
+
   def test_expire_cookies
     values = {  :name     => 'Foo',
                 :value    => 'Bar',
                 :path     => '/',
-                :expires  => DateTime.now + 10,
+                :expires  => Time.now + (10 * 86400),
                 :domain   => 'rubyforge.org'
              }
     url = URI.parse('http://rubyforge.org/')
 
-    jar = WWW::CookieJar.new
+    jar = WWW::Mechanize::CookieJar.new
     assert_equal(0, jar.cookies(url).length)
 
     # Add one cookie with an expiration date in the future
-    cookie = WWW::Cookie.new(values)
+    cookie = WWW::Mechanize::Cookie.new(values)
     jar.add(cookie)
     assert_equal(1, jar.cookies(url).length)
 
     # Add a second cookie
-    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz' )))
+    jar.add(WWW::Mechanize::Cookie.new(values.merge( :name => 'Baz' )))
     assert_equal(2, jar.cookies(url).length)
 
     # Make sure we can get the cookie from different paths
     assert_equal(2, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
 
     # Expire the first cookie
-    jar.add(WWW::Cookie.new(values.merge( :expires => DateTime.now - 10)))
+    jar.add(WWW::Mechanize::Cookie.new(values.merge( :expires => Time.now - (10 * 86400))))
     assert_equal(1, jar.cookies(url).length)
 
     # Expire the second cookie
-    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz',
-                                          :expires => DateTime.now - 10)))
+    jar.add(WWW::Mechanize::Cookie.new(values.merge( :name => 'Baz',
+                                          :expires => Time.now - (10 * 86400))))
     assert_equal(0, jar.cookies(url).length)
   end
 
@@ -105,29 +156,39 @@ class CookieJarTest < Test::Unit::TestCase
              }
     url = URI.parse('http://rubyforge.org/')
 
-    jar = WWW::CookieJar.new
+    jar = WWW::Mechanize::CookieJar.new
     assert_equal(0, jar.cookies(url).length)
 
     # Add one cookie with an expiration date in the future
-    cookie = WWW::Cookie.new(values)
+    cookie = WWW::Mechanize::Cookie.new(values)
     jar.add(cookie)
     assert_equal(1, jar.cookies(url).length)
 
     # Add a second cookie
-    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz' )))
+    jar.add(WWW::Mechanize::Cookie.new(values.merge( :name => 'Baz' )))
     assert_equal(2, jar.cookies(url).length)
 
     # Make sure we can get the cookie from different paths
     assert_equal(2, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
 
     # Expire the first cookie
-    jar.add(WWW::Cookie.new(values.merge( :expires => DateTime.now - 10)))
+    jar.add(WWW::Mechanize::Cookie.new(values.merge( :expires => Time.now - (10 * 86400))))
     assert_equal(1, jar.cookies(url).length)
 
     # Expire the second cookie
-    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz',
-                                          :expires => DateTime.now - 10)))
+    jar.add(WWW::Mechanize::Cookie.new(values.merge( :name => 'Baz',
+                                          :expires => Time.now - (10 * 86400))))
     assert_equal(0, jar.cookies(url).length)
+
+    # When given a URI with a blank path, CookieJar#cookies should return
+    # cookies with the path '/':
+    url = URI.parse('http://rubyforge.org')
+    assert_equal '', url.path    
+    assert_equal(0, jar.cookies(url).length)    
+    # Now add a cookie with the path set to '/':
+    jar.add(WWW::Mechanize::Cookie.new(values.merge( :name => 'has_root_path', 
+                                          :path => '/')))    
+    assert_equal(1, jar.cookies(url).length)
   end
 
   def test_paths
@@ -139,16 +200,16 @@ class CookieJarTest < Test::Unit::TestCase
              }
     url = URI.parse('http://rubyforge.org/login')
 
-    jar = WWW::CookieJar.new
+    jar = WWW::Mechanize::CookieJar.new
     assert_equal(0, jar.cookies(url).length)
 
     # Add one cookie with an expiration date in the future
-    cookie = WWW::Cookie.new(values)
+    cookie = WWW::Mechanize::Cookie.new(values)
     jar.add(cookie)
     assert_equal(1, jar.cookies(url).length)
 
     # Add a second cookie
-    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz' )))
+    jar.add(WWW::Mechanize::Cookie.new(values.merge( :name => 'Baz' )))
     assert_equal(2, jar.cookies(url).length)
 
     # Make sure we don't get the cookie in a different path
@@ -156,12 +217,12 @@ class CookieJarTest < Test::Unit::TestCase
     assert_equal(0, jar.cookies(URI.parse('http://rubyforge.org/')).length)
 
     # Expire the first cookie
-    jar.add(WWW::Cookie.new(values.merge( :expires => DateTime.now - 10)))
+    jar.add(WWW::Mechanize::Cookie.new(values.merge( :expires => Time.now - (10 * 86400))))
     assert_equal(1, jar.cookies(url).length)
 
     # Expire the second cookie
-    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz',
-                                          :expires => DateTime.now - 10)))
+    jar.add(WWW::Mechanize::Cookie.new(values.merge( :name => 'Baz',
+                                          :expires => Time.now - (10 * 86400))))
     assert_equal(0, jar.cookies(url).length)
   end
 end