neocoin-mechanize 2.0.2

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_cookies.rb

@@ -0,0 +1,129 @@
+require "helper"
+
+class CookiesMechTest < MiniTest::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_quoted_value_cookie
+    @agent.get("http://localhost/quoted_value_cookie")
+    quoted_cookie = @agent.cookies.find { |k| k.name == 'quoted' }
+    assert_equal("\"value\"", quoted_cookie.value)
+  end
+
+  def test_meta_tag_cookies
+    cookies = @agent.cookies.length
+    @agent.get("http://localhost/meta_cookie.html")
+    assert_equal(cookies + 1, @agent.cookies.length)
+  end
+
+  def test_send_cookies
+    page = @agent.get("http://localhost/many_cookies")
+    page = @agent.get("http://localhost/send_cookies")
+    assert_equal(3, page.links.length)
+    assert(page.links.find { |l| l.text == "name:Aaron" })
+    assert(page.links.find { |l| l.text == "no_expires:nope" })
+  end
+
+  def test_no_space_cookies
+    @agent.get("http://localhost/one_cookie_no_space")
+    assert_equal(1, @agent.cookies.length)
+    foo_cookie = @agent.cookies.find { |k| k.name == 'foo' }
+    assert(foo_cookie, 'Foo cookie was nil')
+    assert_equal('bar', foo_cookie.value)
+    assert_equal('/', foo_cookie.path)
+    assert_equal(true, Time.now < foo_cookie.expires)
+  end
+
+  def test_many_cookies_as_string
+    @agent.get("http://localhost/many_cookies_as_string")
+    assert_equal(4, @agent.cookies.length)
+
+    name_cookie = @agent.cookies.find { |k| k.name == "name" }
+
+    assert_equal("Aaron", name_cookie.value)
+    assert_equal("/", name_cookie.path)
+    assert_equal(true, Time.now < name_cookie.expires)
+
+    expired_cookie = @agent.cookies.find { |k| k.name == "expired" }
+    assert_nil(expired_cookie, "Expired cookie was not nil")
+
+    no_exp_cookie = @agent.cookies.find { |k| k.name == "no_expires" }
+
+    assert_equal("nope", no_exp_cookie.value)
+    assert_equal("/", no_exp_cookie.path)
+    assert_nil(no_exp_cookie.expires)
+
+    path_cookie = @agent.cookies.find { |k| k.name == "a_path" }
+
+    assert_equal("some_path", path_cookie.value)
+    assert_equal(true, Time.now < path_cookie.expires)
+
+    no_path_cookie = @agent.cookies.find { |k| k.name == "no_path" }
+
+    assert_equal("no_path", no_path_cookie.value)
+    assert_equal("/", no_path_cookie.path)
+    assert_equal(true, Time.now < no_path_cookie.expires)
+  end
+
+  def test_many_cookies
+    @agent.get("http://localhost/many_cookies")
+    assert_equal(4, @agent.cookies.length)
+
+    name_cookie = @agent.cookies.find { |k| k.name == "name" }
+    assert(name_cookie, "Name cookie was nil")
+    assert_equal("Aaron", name_cookie.value)
+    assert_equal("/", name_cookie.path)
+    assert_equal(true, Time.now < name_cookie.expires)
+
+    expired_cookie = @agent.cookies.find { |k| k.name == "expired" }
+    assert_nil(expired_cookie, "Expired cookie was not nil")
+
+    no_exp_cookie = @agent.cookies.find { |k| k.name == "no_expires" }
+    assert(no_exp_cookie, "No expires cookie is nil")
+    assert_equal("nope", no_exp_cookie.value)
+    assert_equal("/", no_exp_cookie.path)
+    assert_nil(no_exp_cookie.expires)
+
+    path_cookie = @agent.cookies.find { |k| k.name == "a_path" }
+    assert(path_cookie, "Path cookie is nil")
+    assert_equal("some_path", path_cookie.value)
+    assert_equal(true, Time.now < path_cookie.expires)
+
+    no_path_cookie = @agent.cookies.find { |k| k.name == "no_path" }
+    assert(no_path_cookie, "No path cookie is nil")
+    assert_equal("no_path", no_path_cookie.value)
+    assert_equal("/", no_path_cookie.path)
+    assert_equal(true, Time.now < no_path_cookie.expires)
+  end
+
+  def test_get_cookie
+    assert_equal(true,
+      @agent.cookie_jar.empty?(
+      URI::parse("http://localhost/one_cookie")))
+
+    assert_equal(0, @agent.cookies.length)
+
+    page = @agent.get("http://localhost/one_cookie")
+    assert_equal(1, @agent.cookies.length)
+
+    cookie = @agent.cookies.first
+    assert_equal("foo", cookie.name)
+    assert_equal("bar", cookie.value)
+    assert_equal("/", cookie.path)
+    assert_equal("localhost", cookie.domain)
+
+    assert_equal(false,
+      @agent.cookie_jar.empty?(
+      URI::parse("http://localhost/one_cookie")))
+    page = @agent.get("http://localhost/one_cookie")
+
+    assert_equal(1, @agent.cookies.length)
+
+    cookie = @agent.cookies.first
+    assert_equal("foo", cookie.name)
+    assert_equal("bar", cookie.value)
+    assert_equal("/", cookie.path)
+    assert_equal("localhost", cookie.domain)
+  end
+end

data/test/test_form_action.rb

@@ -0,0 +1,52 @@
+require "helper"
+
+class TestFormAction < MiniTest::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+    @page  = @agent.get("http://localhost/tc_form_action.html")
+  end
+
+  def test_post_with_bad_encoding_does_not_raise_exception
+    @page  = @agent.get("http://localhost/test_bad_encoding.html")
+    form = @page.form(:name => 'post_form1') { |f|
+      f.first_name = "Aaron"
+    }
+    form.submit
+  end
+
+  def test_post_encoded_action
+    form = @page.form(:name => 'post_form1') { |f|
+      f.first_name = "Aaron"
+    }
+    assert_equal('/form_post?a=b&b=c', form.action)
+    page = form.submit
+    assert_equal("http://localhost/form_post?a=b&b=c", page.uri.to_s)
+  end
+
+  def test_get_encoded_action
+    form = @page.form('post_form2') { |f|
+      f.first_name = "Aaron"
+    }
+    assert_equal('/form_post?a=b&b=c', form.action)
+    page = form.submit
+    assert_equal("http://localhost/form_post?first_name=Aaron", page.uri.to_s)
+  end
+
+  def test_post_nonencoded_action
+    form = @page.form('post_form3') { |f|
+      f.first_name = "Aaron"
+    }
+    assert_equal('/form_post?a=b&b=c', form.action)
+    page = form.submit
+    assert_equal("http://localhost/form_post?a=b&b=c", page.uri.to_s)
+  end
+
+  def test_post_pound_sign
+    form = @page.form('post_form4') { |f|
+      f.first_name = "Aaron"
+    }
+    assert_equal('/form_post#1', form.action)
+    page = form.submit
+    assert_equal("http://localhost/form_post#1", page.uri.to_s)
+  end
+end

data/test/test_form_as_hash.rb

@@ -0,0 +1,59 @@
+require "helper"
+
+class TestFormHash < MiniTest::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+    @page  = @agent.get('http://localhost/form_multival.html')
+  end
+
+  def test_form_hash
+    form = @page.form_with(:name => 'post_form')
+
+    field_length = form.fields.length
+    assert_nil(form['intarweb'])
+    form['intarweb'] = 'Aaron'
+
+    assert form['intarweb']
+    assert_equal(field_length + 1, form.fields.length)
+  end
+
+  def test_add_field_via_hash
+    form = @page.form_with(:name => 'post_form')
+
+    field_length = form.fields.length
+    assert_nil(form['intarweb'])
+    form['intarweb'] = 'Aaron'
+
+    assert form['intarweb']
+    assert_equal(field_length + 1, form.fields.length)
+  end
+
+  def test_fields_as_hash
+    form = @page.form_with(:name => 'post_form')
+
+    assert_equal(2, form.fields_with(:name => 'first').length)
+
+    form['first'] = 'Aaron'
+    assert_equal('Aaron', form['first'])
+    assert_equal('Aaron', form.field_with(:name => 'first').value)
+  end
+
+  def test_keys
+    @page = @agent.get('http://localhost/empty_form.html')
+    form = @page.forms.first
+
+    assert(!form.has_field?('name'))
+    assert(!form.has_value?('Aaron'))
+    assert_equal(0, form.keys.length)
+    assert_equal(0, form.values.length)
+
+    form['name'] = 'Aaron'
+
+    assert(form.has_field?('name'))
+    assert(form.has_value?('Aaron'))
+    assert_equal(1, form.keys.length)
+    assert_equal(['name'], form.keys)
+    assert_equal(1, form.values.length)
+    assert_equal(['Aaron'], form.values)
+  end
+end

data/test/test_form_button.rb

@@ -0,0 +1,46 @@
+require "helper"
+
+class TestFormButtons < MiniTest::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_submit_input_tag
+    assert_form_contains_button('<input type="submit" value="submit" />')
+  end
+
+  def test_button_input_tag
+    assert_form_contains_button('<input type="button" value="submit" />')
+  end
+
+  def test_submit_button_tag
+    assert_form_contains_button('<button type="submit" value="submit"/>')
+  end
+
+  def test_button_button_tag
+    assert_form_contains_button('<button type="button" value="submit"/>')
+  end
+
+  def test_image_button_tag
+    assert_form_contains_button('<input type="image" name="submit" src="http://foo.com/image.jpg"/>')
+  end
+  
+  def test_no_name_image_button_tag
+    assert_form_contains_button('<input type="image" src="http://foo.com/image.jpg"/>')
+  end
+  
+  def assert_form_contains_button(button)
+    page = Mechanize::Page.new(nil, html_response, html(button), 200, @agent)
+    assert_equal(1, page.forms.length)
+    assert_equal(1, page.forms.first.buttons.length)
+  end
+
+  def html(input)
+    "<html><body><form>#{input}</form></body></html>"
+  end
+
+  def html_response
+    { 'content-type' => 'text/html' }
+  end
+end
+

data/test/test_frames.rb

@@ -0,0 +1,34 @@
+require "helper"
+
+class FramesMechTest < MiniTest::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_frames
+    page = @agent.get("http://localhost/frame_test.html")
+    assert_equal(3, page.frames.size)
+    assert_equal("frame1", page.frames[0].name)
+    assert_equal("frame2", page.frames[1].name)
+    assert_equal("frame3", page.frames[2].name)
+    assert_equal("/google.html", page.frames[0].src)
+    assert_equal("/form_test.html", page.frames[1].src)
+    assert_equal("/file_upload.html", page.frames[2].src)
+    assert_equal("Google", page.frames[0].content.title)
+    assert_equal("Page Title", page.frames[1].content.title)
+    assert_equal("File Upload Form", page.frames[2].content.title)
+  end
+
+  def test_iframes
+    page = @agent.get("http://localhost/iframe_test.html")
+    assert_equal(1, page.iframes.size)
+    assert_equal("frame4", page.iframes.first.name)
+    assert_equal("/file_upload.html", page.iframes.first.src)
+    assert_equal("File Upload Form", page.iframes.first.content.title)
+  end
+  
+  def test_frame_referer
+    page = @agent.get("http://localhost/frame_referer_test.html")    
+    assert_equal("http://localhost/frame_referer_test.html", page.frames.first.content.body)
+  end
+end

data/test/test_headers.rb

@@ -0,0 +1,33 @@
+require "helper"
+
+class TestHeaders < MiniTest::Unit::TestCase
+  def setup
+    @headers = Mechanize::Headers.new
+    @headers['content-type'] = 'text/html'
+    @headers['Content-encoding'] = 'gzip'
+    @headers['SERVER'] = 'Apache/2.2'
+  end
+
+  def test_aref
+    assert_equal('Apache/2.2', @headers['server'])
+    assert_equal('text/html', @headers['Content-Type'])
+  end
+
+  def test_key?
+    assert_equal(true, @headers.key?('content-Encoding'))
+  end
+
+  def test_canonical_each
+    all_keys = ['Content-Type', 'Content-Encoding', 'Server']
+    keys = all_keys.dup
+    @headers.canonical_each { |key, value|
+      case keys.delete(key)
+      when *all_keys
+        # ok
+      else
+        flunk "unexpected key: #{key}"
+      end
+    }
+    assert_equal([], keys)
+  end
+end

data/test/test_history.rb

@@ -0,0 +1,118 @@
+require "helper"
+
+class TestHistory < MiniTest::Unit::TestCase
+
+  Node = Struct.new :href, :inner_text
+
+  def setup
+    @mech    = Mechanize.new
+    @history = Mechanize::History.new
+    @uri = URI 'http://example'
+  end
+
+  def test_initialize
+    assert_equal 0, @history.length
+  end
+
+  def test_push
+    response = { 'content-type' => 'text/html' }
+    page = Mechanize::Page.new @uri, response, '', 200, @mech
+
+    obj = @history.push page
+
+    assert_same @history, obj
+    assert_equal 1, @history.length
+    assert @history.visited? @uri
+
+    page = Mechanize::Page.new @uri + '/a', response, '', 200, @mech
+
+    @history.push page
+
+    assert_equal 2, @history.length
+  end
+
+  def test_push_uri
+    obj = @history.push :page, @uri
+
+    assert_same @history, obj
+    assert_equal 1, @history.length
+
+    assert @history.visited? @uri
+
+    @history.push :page2, @uri
+
+    assert_equal 2, @history.length
+  end
+
+  def test_shift
+    assert_nil @history.shift
+
+    @history.push(:page1, @uri)
+    @history.push(:page2, @uri + '/a')
+
+    page = @history.shift
+
+    assert_equal :page1, page
+    assert_equal 1, @history.length
+    assert !@history.visited?(@uri)
+
+    @history.shift
+
+    assert_equal 0, @history.length
+  end
+
+  def test_pop
+    @history.push(:page, @uri)
+
+    assert_equal(:page, @history.pop)
+    assert_equal 0, @history.length
+    assert !@history.visited?(@uri)
+
+    assert_nil @history.pop
+  end
+
+  def test_max_size
+    @history = Mechanize::History.new 2
+
+    1.upto(3) do |i|
+      @history.push :page, @uri
+
+      if i >= 2
+        assert_equal 2, @history.length
+      else
+        assert_equal i, @history.length
+      end
+    end
+  end
+
+  def test_visited_eh
+    @mech.get('http://localhost/')
+
+    node = Struct.new(:href, :inner_text).new('http://localhost/', 'blah')
+    link = Mechanize::Page::Link.new(node, nil, nil)
+    assert(@mech.visited?(link))
+
+    node = Struct.new(:href, :inner_text).new('http://localhost', 'blah')
+    link = Mechanize::Page::Link.new(node, nil, nil)
+    assert(@mech.visited?(link))
+  end
+
+  def test_visited_eh_no_slash
+    slash    = URI 'http://example/'
+    no_slash = URI 'http://example'
+
+    @history.push :page, slash
+
+    assert @history.visited?(slash),    'slash'
+    assert @history.visited?(no_slash), 'no slash'
+  end
+
+  def test_clear
+    @history.push :page, @uri
+
+    @history.clear
+
+    assert_equal 0, @history.length
+    assert !@history.visited?(@uri)
+  end
+end