diamond-mechanize 2.2 → 2.3

data/test/test_mechanize_http_auth_challenge.rb

@@ -0,0 +1,39 @@
+require 'mechanize/test_case'
+
+class TestMechanizeHttpAuthChallenge < Mechanize::TestCase
+
+  def setup
+    super
+
+    @uri = URI 'http://example/'
+    @AR = Mechanize::HTTP::AuthRealm
+    @AC = Mechanize::HTTP::AuthChallenge
+    @challenge = @AC.new 'Digest', 'realm' => 'r'
+  end
+
+  def test_realm_basic
+    @challenge.scheme = 'Basic'
+
+    expected = @AR.new 'Basic', @uri, 'r'
+
+    assert_equal expected, @challenge.realm(@uri + '/foo')
+  end
+
+  def test_realm_digest
+    expected = @AR.new 'Digest', @uri, 'r'
+
+    assert_equal expected, @challenge.realm(@uri + '/foo')
+  end
+
+  def test_realm_unknown
+    @challenge.scheme = 'Unknown'
+
+    e = assert_raises Mechanize::Error do
+      @challenge.realm(@uri + '/foo')
+    end
+
+    assert_equal 'unknown HTTP authentication scheme Unknown', e.message
+  end
+
+end
+

data/test/test_mechanize_http_auth_realm.rb

@@ -0,0 +1,49 @@
+require 'mechanize/test_case'
+
+class TestMechanizeHttpAuthRealm < Mechanize::TestCase
+
+  def setup
+    super
+
+    @uri = URI 'http://example/'
+    @AR = Mechanize::HTTP::AuthRealm
+    @realm = @AR.new 'Digest', @uri, 'r'
+  end
+
+  def test_initialize
+    assert_equal 'r', @realm.realm
+
+    realm = @AR.new 'Digest', @uri, 'R'
+    assert_equal 'r', realm.realm
+
+    realm = @AR.new 'Digest', @uri, nil
+    assert_nil realm.realm
+  end
+
+  def test_equals2
+    other = @realm.dup
+    assert_equal @realm, other
+
+    other = @AR.new 'Basic', @uri, 'r'
+    refute_equal @realm, other
+
+    other = @AR.new 'Digest', URI('http://other.example/'), 'r'
+    refute_equal @realm, other
+
+    other = @AR.new 'Digest', @uri, 's'
+    refute_equal @realm, other
+  end
+
+  def test_hash
+    h = {}
+    h[@realm] = 1
+
+    other = @realm.dup
+    assert_equal 1, h[other]
+
+    other = @AR.new 'Basic', @uri, 'r'
+    assert_nil h[other]
+  end
+
+end
+

data/test/test_mechanize_http_content_disposition_parser.rb

@@ -0,0 +1,118 @@
+require 'mechanize/test_case'
+
+class TestMechanizeHttpContentDispositionParser < Mechanize::TestCase
+
+  def setup
+    super
+
+    @parser = Mechanize::HTTP::ContentDispositionParser.new
+  end
+
+  def test_parse
+    now = Time.at Time.now.to_i
+
+    content_disposition = @parser.parse \
+      'attachment;' \
+      'filename=value;' \
+      "creation-date=\"#{now.rfc822}\";" \
+      "modification-date=\"#{(now + 1).rfc822}\";" \
+      "read-date=\"#{(now + 2).rfc822}\";" \
+      'size=5;' \
+      'arbitrary=value'
+
+    assert_equal 'attachment', content_disposition.type
+    assert_equal 'value',      content_disposition.filename
+    assert_equal now,          content_disposition.creation_date
+    assert_equal((now + 1),    content_disposition.modification_date)
+    assert_equal((now + 2),    content_disposition.read_date)
+    assert_equal 5,            content_disposition.size
+    expected = { 'arbitrary' => 'value' }
+    assert_equal expected,     content_disposition.parameters
+  end
+
+  def test_parse_header
+    content_disposition = @parser.parse \
+      'content-disposition: attachment;filename=value', true
+
+    assert_equal 'attachment', content_disposition.type
+    assert_equal 'value',      content_disposition.filename
+  end
+
+  def test_parse_no_type
+    content_disposition = @parser.parse 'filename=value'
+
+    assert_nil            content_disposition.type
+    assert_equal 'value', content_disposition.filename
+  end
+
+  def test_parse_semicolons
+    content_disposition = @parser.parse 'attachment;;filename=value'
+
+    assert_equal 'attachment', content_disposition.type
+    assert_equal 'value',      content_disposition.filename
+  end
+
+  def test_rfc_2045_quoted_string
+    @parser.scanner = StringScanner.new '"text"'
+
+    string = @parser.rfc_2045_quoted_string
+
+    assert_equal 'text', string
+  end
+
+  def test_rfc_2045_quoted_string_bad
+    @parser.scanner = StringScanner.new '"text'
+
+    assert_nil @parser.rfc_2045_quoted_string
+  end
+
+  def test_rfc_2045_quoted_string_crlf
+    @parser.scanner = StringScanner.new "\"multiline\\\r\n\ttext\""
+
+    string = @parser.rfc_2045_quoted_string
+
+    assert_equal "multiline\r\n\ttext", string
+  end
+
+  def test_rfc_2045_quoted_string_escape
+    @parser.scanner = StringScanner.new "\"escape\\ text\""
+
+    string = @parser.rfc_2045_quoted_string
+
+    assert_equal 'escape text', string
+  end
+
+  def test_rfc_2045_quoted_string_escape_bad
+    @parser.scanner = StringScanner.new '"escape\\'
+
+    string = @parser.rfc_2045_quoted_string
+
+    assert_nil string
+  end
+
+  def test_rfc_2045_quoted_string_folded
+    @parser.scanner = StringScanner.new "\"multiline\r\n\ttext\""
+
+    string = @parser.rfc_2045_quoted_string
+
+    assert_equal 'multiline text', string
+  end
+
+  def test_rfc_2045_quoted_string_quote
+    @parser.scanner = StringScanner.new '"escaped \\" here"'
+
+    string = @parser.rfc_2045_quoted_string
+
+    assert_equal 'escaped " here', string
+  end
+
+  def test_rfc_2045_quoted_string_quote_end
+    @parser.scanner = StringScanner.new '"end \\""'
+
+    string = @parser.rfc_2045_quoted_string
+
+    assert_equal 'end "', string
+  end
+
+end
+

data/test/test_mechanize_http_www_authenticate_parser.rb

@@ -0,0 +1,146 @@
+require 'mechanize/test_case'
+
+class TestMechanizeHttpWwwAuthenticateParser < Mechanize::TestCase
+
+  def setup
+    super
+
+    @parser = Mechanize::HTTP::WWWAuthenticateParser.new
+  end
+
+  def test_auth_param
+    @parser.scanner = StringScanner.new 'realm=here'
+
+    param = @parser.auth_param
+
+    assert_equal %w[realm here], param
+  end
+
+  def test_auth_param_bad_no_value
+    @parser.scanner = StringScanner.new 'realm='
+
+    assert_nil @parser.auth_param
+  end
+
+  def test_auth_param_bad_token
+    @parser.scanner = StringScanner.new 'realm'
+
+    assert_nil @parser.auth_param
+  end
+
+  def test_auth_param_bad_value
+    @parser.scanner = StringScanner.new 'realm="this '
+
+    assert_nil @parser.auth_param
+  end
+
+  def test_auth_param_quoted
+    @parser.scanner = StringScanner.new 'realm="this site"'
+
+    param = @parser.auth_param
+
+    assert_equal ['realm', 'this site'], param
+  end
+
+  def test_parse
+    expected = [
+      challenge('Basic', { 'realm' => 'foo' }),
+    ]
+
+    assert_equal expected, @parser.parse('Basic realm=foo')
+  end
+
+  def test_parse_multiple
+    expected = [
+      challenge('Basic', { 'realm' => 'foo' }),
+      challenge('Digest', { 'realm' => 'foo' }),
+    ]
+
+    assert_equal expected, @parser.parse('Basic realm=foo, Digest realm=foo')
+  end
+
+  def test_parse_multiple_blank
+    expected = [
+      challenge('Basic', { 'realm' => 'foo' }),
+      challenge('Digest', { 'realm' => 'foo' }),
+    ]
+
+    assert_equal expected, @parser.parse('Basic realm=foo,, Digest realm=foo')
+  end
+
+  def test_parse_ntlm_init
+    expected = [
+      challenge('NTLM', nil),
+    ]
+
+    assert_equal expected, @parser.parse('NTLM')
+  end
+
+  def test_parse_ntlm_type_2_3
+    expected = [
+      challenge('NTLM', 'foo='),
+    ]
+
+    assert_equal expected, @parser.parse('NTLM foo=')
+  end
+
+  def test_quoted_string
+    @parser.scanner = StringScanner.new '"text"'
+
+    string = @parser.quoted_string
+
+    assert_equal 'text', string
+  end
+
+  def test_quoted_string_bad
+    @parser.scanner = StringScanner.new '"text'
+
+    assert_nil @parser.quoted_string
+  end
+
+  def test_quoted_string_quote
+    @parser.scanner = StringScanner.new '"escaped \\" here"'
+
+    string = @parser.quoted_string
+
+    assert_equal 'escaped \\" here', string
+  end
+
+  def test_quoted_string_quote_end
+    @parser.scanner = StringScanner.new '"end \""'
+
+    string = @parser.quoted_string
+
+    assert_equal 'end \"', string
+  end
+
+  def test_token
+    @parser.scanner = StringScanner.new 'text'
+
+    string = @parser.token
+
+    assert_equal 'text', string
+  end
+
+  def test_token_space
+    @parser.scanner = StringScanner.new 't ext'
+
+    string = @parser.token
+
+    assert_equal 't', string
+  end
+
+  def test_token_special
+    @parser.scanner = StringScanner.new "t\text"
+
+    string = @parser.token
+
+    assert_equal 't', string
+  end
+
+  def challenge scheme, params
+    Mechanize::HTTP::AuthChallenge.new scheme, params
+  end
+
+end
+

data/test/test_mechanize_link.rb

@@ -0,0 +1,80 @@
+require 'mechanize/test_case'
+
+class TestMechanizeLink < Mechanize::TestCase
+
+  def test_click
+    page = @mech.get("http://localhost/frame_test.html")
+    link = page.link_with(:text => "Form Test")
+
+    assert_equal('Form Test', link.text)
+    page = link.click
+    assert_equal("http://localhost/form_test.html",
+      @mech.history.last.uri.to_s)
+  end
+
+  def test_click_base
+    page = @mech.get("http://google.com/tc_base_link.html")
+    page = page.links.first.click
+    assert @mech.visited?("http://localhost/index.html")
+  end
+
+  def test_click_unsupported_scheme
+    page = @mech.get("http://google.com/tc_links.html")
+    link = page.link_with(:text => 'javascript link')
+    assert_raises Mechanize::UnsupportedSchemeError do
+      link.click
+    end
+
+    @mech.scheme_handlers['javascript'] = lambda { |my_link, my_page|
+      URI.parse('http://localhost/tc_links.html')
+    }
+
+    link.click
+
+    # HACK no assertion
+  end
+
+  def test_text_alt_text
+    page = @mech.get("http://localhost/alt_text.html")
+    assert_equal(5, page.links.length)
+    assert_equal(1, page.meta_refresh.length)
+
+    assert_equal '',         page.meta_refresh.first.text
+    assert_equal 'alt text', page.link_with(:href => 'alt_text.html').text
+    assert_equal '',         page.link_with(:href => 'no_alt_text.html').text
+    assert_equal 'no image', page.link_with(:href => 'no_image.html').text
+    assert_equal '',         page.link_with(:href => 'no_text.html').text
+    assert_equal '',         page.link_with(:href => 'nil_alt_text.html').text
+  end
+
+  def test_uri_escaped
+    doc = Nokogiri::HTML::Document.new
+
+    node = Nokogiri::XML::Node.new('foo', doc)
+    node['href'] = 'http://foo.bar/%20baz'
+
+    link = Mechanize::Page::Link.new(node, nil, nil)
+
+    assert_equal 'http://foo.bar/%20baz', link.uri.to_s
+  end
+
+  def test_uri_no_path
+    page = @mech.get("http://localhost/relative/tc_relative_links.html")
+    page = page.link_with(:text => 'just the query string').click
+    assert_equal('http://localhost/relative/tc_relative_links.html?a=b',
+                 page.uri.to_s)
+  end
+
+  def test_uri_weird
+    doc = Nokogiri::HTML::Document.new
+
+    node = Nokogiri::XML::Node.new('foo', doc)
+    node['href'] = 'http://foo.bar/ baz'
+
+    link = Mechanize::Page::Link.new(node, nil, nil)
+
+    assert_equal 'http://foo.bar/%20baz', link.uri.to_s
+  end
+
+end
+

data/test/test_mechanize_page.rb

@@ -0,0 +1,118 @@
+require 'mechanize/test_case'
+
+class TestMechanizePage < Mechanize::TestCase
+
+  def setup
+    super
+
+    @uri = URI 'http://example/'
+  end
+
+  def test_initialize_bad_content_type
+    e = assert_raises Mechanize::ContentTypeError do
+      Mechanize::Page.new(URI('http://example/'),
+                          { 'content-type' => 'text/xml' }, 'hello', '200')
+    end
+
+    assert_equal('text/xml', e.content_type)
+  end
+
+  def test_frames
+    page = html_page <<-BODY
+<TITLE>A simple frameset document</TITLE>
+<FRAMESET cols="20%, 80%">
+  <FRAMESET rows="100, 200">
+  <FRAME name="frame1" src="/google.html">
+  <FRAME name="frame2" src="/form_test.html">
+  </FRAMESET>
+  <FRAMESET rows="100, 200">
+  <FRAME name="frame3" src="/file_upload.html">
+  <IFRAME src="http://google.com/" name="frame4"></IFRAME>
+  </FRAMESET>
+</FRAMESET>
+    BODY
+
+    assert_equal 3, page.frames.size
+    assert_equal "frame1",       page.frames[0].name
+    assert_equal "/google.html", page.frames[0].src
+    assert_equal "Google",       page.frames[0].content.title
+
+    assert_equal "frame2",          page.frames[1].name
+    assert_equal "/form_test.html", page.frames[1].src
+    assert_equal "Page Title",      page.frames[1].content.title
+
+    assert_equal "frame3",            page.frames[2].name
+    assert_equal "/file_upload.html", page.frames[2].src
+    assert_equal "File Upload Form",  page.frames[2].content.title
+  end
+
+  def test_iframes
+    page = html_page <<-BODY
+<TITLE>A simple frameset document</TITLE>
+<FRAME name="frame1" src="/google.html">
+<IFRAME src="/file_upload.html" name="frame4">
+</IFRAME>
+    BODY
+
+    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_images
+    page = html_page <<-BODY
+<img src="a.jpg">
+    BODY
+
+    assert_equal page.images.first.url, "http://example/a.jpg"
+  end
+
+  def test_images_base
+    page = html_page <<-BODY
+<head>
+  <base href="http://other.example/">
+</head>
+<body>
+  <img src="a.jpg">
+</body>
+    BODY
+
+    assert_equal page.images.first.url, "http://other.example/a.jpg"
+  end
+
+  def test_links
+    page = html_page <<-BODY
+<a href="foo.html">
+    BODY
+
+    assert_equal page.links.first.href, "foo.html"
+  end
+
+  def test_parser_no_attributes
+    page = html_page <<-BODY
+<html>
+  <meta>
+  <head><title></title>
+  <body>
+    <a>Hello</a>
+    <a><img /></a>
+    <form>
+      <input />
+      <select>
+        <option />
+      </select>
+      <textarea></textarea>
+    </form>
+    <frame></frame>
+  </body>
+</html>
+    BODY
+
+    # HACK weak assertion
+    assert_kind_of Nokogiri::HTML::Document, page.root
+  end
+
+end
+