diamond-mechanize 2.1 → 2.2

data/test/test_mechanize_http_auth_challenge.rb

@@ -1,39 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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
-