knu-mechanize 0.9.3.20090623142847

data/test/ssl_server.rb

@@ -0,0 +1,48 @@
+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/test_authenticate.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+require 'pp'
+
+class BasicAuthTest < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_auth_success
+    @agent.basic_auth('user', 'pass')
+    page = @agent.get("http://localhost/basic_auth")
+    assert_equal('You are authenticated', page.body)
+  end
+
+  def test_digest_auth_success
+    @agent.basic_auth('user', 'pass')
+    page = @agent.get("http://localhost/digest_auth")
+    assert_equal('You are authenticated', page.body)
+  end
+
+  def test_no_duplicate_headers
+    block_called = false
+    @agent.pre_connect_hooks << lambda { |params|
+      block_called = true
+      params[:request].to_hash.each do |k,v|
+        assert_equal(1, v.length)
+      end
+    }
+    @agent.basic_auth('user', 'pass')
+    page = @agent.get("http://localhost/digest_auth")
+    assert block_called
+  end
+
+  def test_post_auth_success
+    class << @agent
+      alias :old_fetch_page :fetch_page
+      attr_accessor :requests
+      def fetch_page(args)
+        @requests ||= []
+        x = old_fetch_page(args)
+        @requests << args[:verb]
+        x
+      end
+    end
+    @agent.basic_auth('user', 'pass')
+    page = @agent.post("http://localhost/basic_auth")
+    assert_equal('You are authenticated', page.body)
+    assert_equal(2, @agent.requests.length)
+    r1 = @agent.requests[0]
+    r2 = @agent.requests[1]
+    assert_equal(r1, r2)
+  end
+
+  def test_auth_bad_user_pass
+    @agent.basic_auth('aaron', 'aaron')
+    begin
+      page = @agent.get("http://localhost/basic_auth")
+    rescue WWW::Mechanize::ResponseCodeError => e
+      assert_equal("401", e.response_code)
+    end
+  end
+
+  def test_auth_failure
+    begin
+      page = @agent.get("http://localhost/basic_auth")
+    rescue WWW::Mechanize::ResponseCodeError => e
+      assert_equal("401", e.response_code)
+    end
+  end
+
+end

data/test/test_bad_links.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class TestBadLinks < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+    @page = @agent.get("http://localhost/tc_bad_links.html")
+  end
+
+  def test_space_in_link
+    assert_nothing_raised do
+      @agent.click @page.links.first
+    end
+    assert_match(/alt_text.html$/, @agent.history.last.uri.to_s)
+    assert_equal(2, @agent.history.length)
+  end
+
+  def test_space_in_url
+    page = nil
+    assert_nothing_raised do
+      page = @agent.get("http://localhost/tc_bad_links.html ")
+    end
+    assert_match(/tc_bad_links.html$/, @agent.history.last.uri.to_s)
+    assert_equal(2, @agent.history.length)
+  end
+end

data/test/test_blank_form.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class BlankFormTest < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_blank_form_query_string
+    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
+end
+

data/test/test_checkboxes.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class TestCheckBoxes < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+    @page = @agent.get('http://localhost/tc_checkboxes.html')
+  end
+
+  def test_select_one
+    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_select_all
+    form = @page.forms.first
+    form.checkboxes.each do |b|
+      b.check
+    end
+    form.checkboxes.each do |b|
+      assert_equal(true, b.checked)
+    end
+  end
+
+  def test_select_none
+    form = @page.forms.first
+    form.checkboxes.each do |b|
+      b.uncheck
+    end
+    form.checkboxes.each do |b|
+      assert_equal(false, b.checked)
+    end
+  end
+
+  def test_check_one
+    form = @page.forms.first
+    assert_equal(2, form.checkboxes_with(:name => 'green').length)
+    form.checkboxes_with(:name => 'green')[1].check
+    assert_equal(false,  form.checkboxes_with(:name => 'green')[0].checked)
+    assert_equal(true,  form.checkboxes_with(:name => 'green')[1].checked)
+    page = @agent.submit(form)
+    assert_equal(1, page.links.length)
+    assert_equal('green:on', page.links.first.text)
+  end
+
+  def test_check_two
+    form = @page.forms.first
+    assert_equal(2, form.checkboxes_with(:name => 'green').length)
+    form.checkboxes_with(:name => 'green')[0].check
+    form.checkboxes_with(:name => 'green')[1].check
+    assert_equal(true,  form.checkboxes_with(:name => 'green')[0].checked)
+    assert_equal(true,  form.checkboxes_with(:name => 'green')[1].checked)
+    page = @agent.submit(form)
+    assert_equal(2, page.links.length)
+    assert_equal('green:on', page.links.first.text)
+    assert_equal('green:on', page.links[1].text)
+  end
+end

data/test/test_content_type.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class TestContentType < Test::Unit::TestCase
+  def setup
+    @agent = WWW::Mechanize.new
+  end
+
+  def test_application_xhtml_xml
+    url = 'http://localhost/content_type_test?ct=application/xhtml%2Bxml'
+    page = @agent.get url
+    assert_equal WWW::Mechanize::Page, page.class, "xhtml docs should return a Page"
+  end
+end

data/test/test_cookie_class.rb

@@ -0,0 +1,338 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+module Enumerable
+  def combine
+    masks = inject([[], 1]){|(ar, m), e| [ar << m, m << 1 ] }[0]
+    all = masks.inject(0){ |al, m| al|m }
+
+    result = []
+    for i in 1..all do
+      tmp = []
+      each_with_index do |e, idx|
+        tmp << e unless (masks[idx] & i) == 0
+      end
+      result << tmp
+    end
+    result
+  end
+end
+
+class CookieClassTest < Test::Unit::TestCase
+  def silently
+    warn_level = $VERBOSE
+    $VERBOSE = false
+    res = yield
+    $VERBOSE = warn_level
+    res
+  end
+
+  def test_parse_dates
+    url = URI.parse('http://localhost/')
+
+    yesterday = Time.now - 86400
+
+    dates = [ "14 Apr 89 03:20:12",
+              "14 Apr 89 03:20 GMT",
+              "Fri, 17 Mar 89 4:01:33",
+              "Fri, 17 Mar 89 4:01 GMT",
+              "Mon Jan 16 16:12 PDT 1989",
+              "Mon Jan 16 16:12 +0130 1989",
+              "6 May 1992 16:41-JST (Wednesday)",
+              #"22-AUG-1993 10:59:12.82",
+              "22-AUG-1993 10:59pm",
+              "22-AUG-1993 12:59am",
+              "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",
+              "95-06-08 19:32:48 EDT",
+    ]
+
+    dates.each do |date|
+      cookie = "PREF=1; expires=#{date}"
+      silently do
+        WWW::Mechanize::Cookie.parse(url, cookie) { |c|
+          assert c.expires, "Tried parsing: #{date}"
+          assert_equal(true, c.expires < yesterday)
+        }
+      end
+    end
+  end
+
+  def test_parse_weird_cookie
+    cookie = 'n/a, ASPSESSIONIDCSRRQDQR=FBLDGHPBNDJCPCGNCPAENELB; path=/'
+    url = URI.parse('http://www.searchinnovation.com/')
+    WWW::Mechanize::Cookie.parse(url, cookie) { |c|
+      assert_equal('ASPSESSIONIDCSRRQDQR', c.name)
+      assert_equal('FBLDGHPBNDJCPCGNCPAENELB', c.value)
+    }
+  end
+
+  def test_double_semicolon
+    double_semi = 'WSIDC=WEST;; domain=.williams-sonoma.com; path=/'
+    url = URI.parse('http://williams-sonoma.com/')
+    WWW::Mechanize::Cookie.parse(url, double_semi) { |cookie|
+      assert_equal('WSIDC', cookie.name)
+      assert_equal('WEST', cookie.value)
+    }
+  end
+
+  def test_parse_bad_version
+    bad_cookie = 'PRETANET=TGIAqbFXtt; Name=/PRETANET; Path=/; Version=1.2; Content-type=text/html; Domain=192.168.6.196; expires=Friday, 13-November-2026  23:01:46 GMT;'
+    url = URI.parse('http://localhost/')
+    WWW::Mechanize::Cookie.parse(url, bad_cookie) { |cookie|
+      assert_nil(cookie.version)
+    }
+  end
+
+  def test_parse_bad_max_age
+    bad_cookie = 'PRETANET=TGIAqbFXtt; Name=/PRETANET; Path=/; Max-Age=1.2; Content-type=text/html; Domain=192.168.6.196; expires=Friday, 13-November-2026  23:01:46 GMT;'
+    url = URI.parse('http://localhost/')
+    WWW::Mechanize::Cookie.parse(url, bad_cookie) { |cookie|
+      assert_nil(cookie.max_age)
+    }
+  end
+
+  def test_parse_date_fail
+    url = URI.parse('http://localhost/')
+
+    dates = [ 
+              "20/06/95 21:07",
+    ]
+
+    silently do
+      dates.each do |date|
+        cookie = "PREF=1; expires=#{date}"
+        WWW::Mechanize::Cookie.parse(url, cookie) { |c|
+          assert_equal(true, c.expires.nil?)
+        }
+      end
+    end
+  end
+
+  def test_parse_valid_cookie
+    url = URI.parse('http://rubyforge.org/')
+    cookie_params = {}
+    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
+    cookie_params['path']      = 'path=/'
+    cookie_params['domain']    = 'domain=.rubyforge.org'
+    cookie_params['httponly']  = 'HttpOnly'
+    cookie_value = '12345%7D=ASDFWEE345%3DASda'
+
+    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
+    
+    cookie_params.keys.combine.each do |c|
+      cookie_text = "#{cookie_value}; "
+      c.each_with_index do |key, idx|
+        if idx == (c.length - 1)
+          cookie_text << "#{cookie_params[key]}"
+        else
+          cookie_text << "#{cookie_params[key]}; "
+        end
+      end
+      cookie = nil
+      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)
+      assert_equal('rubyforge.org', cookie.domain)
+
+      # if expires was set, make sure we parsed it
+      if c.find { |k| k == 'expires' }
+        assert_equal(expires, cookie.expires)
+      else
+        assert_nil(cookie.expires)
+      end
+    end
+  end
+
+  def test_parse_valid_cookie_empty_value
+    url = URI.parse('http://rubyforge.org/')
+    cookie_params = {}
+    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
+    cookie_params['path']      = 'path=/'
+    cookie_params['domain']    = 'domain=.rubyforge.org'
+    cookie_params['httponly']  = 'HttpOnly'
+    cookie_value = '12345%7D='
+
+    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
+    
+    cookie_params.keys.combine.each do |c|
+      cookie_text = "#{cookie_value}; "
+      c.each_with_index do |key, idx|
+        if idx == (c.length - 1)
+          cookie_text << "#{cookie_params[key]}"
+        else
+          cookie_text << "#{cookie_params[key]}; "
+        end
+      end
+      cookie = nil
+      WWW::Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
+      assert_not_nil(cookie)
+      assert_equal('12345%7D=', cookie.to_s)
+      assert_equal('', cookie.value)
+      assert_equal('/', cookie.path)
+      assert_equal('rubyforge.org', cookie.domain)
+
+      # if expires was set, make sure we parsed it
+      if c.find { |k| k == 'expires' }
+        assert_equal(expires, cookie.expires)
+      else
+        assert_nil(cookie.expires)
+      end
+    end
+  end
+
+  # If no path was given, use the one from the URL
+  def test_cookie_using_url_path
+    url = URI.parse('http://rubyforge.org/login.php')
+    cookie_params = {}
+    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
+    cookie_params['path']      = 'path=/'
+    cookie_params['domain']    = 'domain=.rubyforge.org'
+    cookie_params['httponly']  = 'HttpOnly'
+    cookie_value = '12345%7D=ASDFWEE345%3DASda'
+
+    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' }
+      cookie_text = "#{cookie_value}; "
+      c.each_with_index do |key, idx|
+        if idx == (c.length - 1)
+          cookie_text << "#{cookie_params[key]}"
+        else
+          cookie_text << "#{cookie_params[key]}; "
+        end
+      end
+      cookie = nil
+      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)
+      assert_equal('/', cookie.path)
+
+      # if expires was set, make sure we parsed it
+      if c.find { |k| k == 'expires' }
+        assert_equal(expires, cookie.expires)
+      else
+        assert_nil(cookie.expires)
+      end
+    end
+  end
+
+  # Test using secure cookies
+  def test_cookie_with_secure
+    url = URI.parse('http://rubyforge.org/')
+    cookie_params = {}
+    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
+    cookie_params['path']      = 'path=/'
+    cookie_params['domain']    = 'domain=.rubyforge.org'
+    cookie_params['secure']    = 'secure'
+    cookie_value = '12345%7D=ASDFWEE345%3DASda'
+
+    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' }
+      cookie_text = "#{cookie_value}; "
+      c.each_with_index do |key, idx|
+        if idx == (c.length - 1)
+          cookie_text << "#{cookie_params[key]}"
+        else
+          cookie_text << "#{cookie_params[key]}; "
+        end
+      end
+      cookie = nil
+      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)
+      assert_equal('/', cookie.path)
+      assert_equal(true, cookie.secure)
+
+      # if expires was set, make sure we parsed it
+      if c.find { |k| k == 'expires' }
+        assert_equal(expires, cookie.expires)
+      else
+        assert_nil(cookie.expires)
+      end
+    end
+  end
+
+  # If no domain was given, we must use the one from the URL
+  def test_cookie_with_url_domain
+    url = URI.parse('http://login.rubyforge.org/')
+    cookie_params = {}
+    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
+    cookie_params['path']      = 'path=/'
+    cookie_params['domain']    = 'domain=.rubyforge.org'
+    cookie_params['httponly']  = 'HttpOnly'
+    cookie_value = '12345%7D=ASDFWEE345%3DASda'
+
+    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' }
+      cookie_text = "#{cookie_value}; "
+      c.each_with_index do |key, idx|
+        if idx == (c.length - 1)
+          cookie_text << "#{cookie_params[key]}"
+        else
+          cookie_text << "#{cookie_params[key]}; "
+        end
+      end
+      cookie = nil
+      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)
+
+      assert_equal('login.rubyforge.org', cookie.domain)
+
+      # if expires was set, make sure we parsed it
+      if c.find { |k| k == 'expires' }
+        assert_equal(expires, cookie.expires)
+      else
+        assert_nil(cookie.expires)
+      end
+    end
+  end
+
+  def test_parse_cookie_no_spaces
+    url = URI.parse('http://rubyforge.org/')
+    cookie_params = {}
+    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
+    cookie_params['path']      = 'path=/'
+    cookie_params['domain']    = 'domain=.rubyforge.org'
+    cookie_params['httponly']  = 'HttpOnly'
+    cookie_value = '12345%7D=ASDFWEE345%3DASda'
+
+    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
+    
+    cookie_params.keys.combine.each do |c|
+      cookie_text = "#{cookie_value};"
+      c.each_with_index do |key, idx|
+        if idx == (c.length - 1)
+          cookie_text << "#{cookie_params[key]}"
+        else
+          cookie_text << "#{cookie_params[key]};"
+        end
+      end
+      cookie = nil
+      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)
+      assert_equal('rubyforge.org', cookie.domain)
+
+      # if expires was set, make sure we parsed it
+      if c.find { |k| k == 'expires' }
+        assert_equal(expires, cookie.expires)
+      else
+        assert_nil(cookie.expires)
+      end
+    end
+  end
+end
+