mechanize 2.14.1 → 2.14.2

data/test/test_mechanize_http_www_authenticate_parser.rb

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-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', 'qop' => 'auth,auth-int' }, 'Basic realm=foo, qop="auth,auth-int"'),
-    ]
-
-    assert_equal expected, @parser.parse('Basic realm=foo, qop="auth,auth-int"')
-  end
-
-  def test_parse_without_comma_delimiter
-    expected = [
-      challenge('Basic', { 'realm' => 'foo', 'qop' => 'auth,auth-int' }, 'Basic realm=foo qop="auth,auth-int"'),
-    ]
-
-    assert_equal expected, @parser.parse('Basic realm=foo qop="auth,auth-int"')
-  end
-
-  def test_parse_multiple
-    expected = [
-      challenge('Basic',  { 'realm' => 'foo' }, 'Basic realm=foo'),
-      challenge('Digest', { 'realm' => 'bar' }, 'Digest realm=bar'),
-    ]
-
-    assert_equal expected, @parser.parse('Basic realm=foo, Digest realm=bar')
-  end
-
-  def test_parse_multiple_without_comma_delimiter
-    expected = [
-      challenge('Basic',  { 'realm' => 'foo' }, 'Basic realm=foo'),
-      challenge('Digest', { 'realm' => 'bar' }, 'Digest realm=bar'),
-    ]
-
-    assert_equal expected, @parser.parse('Basic realm=foo Digest realm=bar')
-  end
-
-  def test_parse_multiple_blank
-    expected = [
-      challenge('Basic',  { 'realm' => 'foo' }, 'Basic realm=foo'),
-      challenge('Digest', { 'realm' => 'bar' }, 'Digest realm=bar'),
-    ]
-
-    assert_equal expected, @parser.parse('Basic realm=foo,, Digest realm=bar')
-  end
-
-  def test_parse_ntlm_init
-    expected = [
-      challenge('NTLM', nil, 'NTLM'),
-    ]
-
-    assert_equal expected, @parser.parse('NTLM')
-  end
-
-  def test_parse_ntlm_type_2_3
-    expected = [
-      challenge('NTLM', 'foo=', 'NTLM foo='),
-    ]
-
-    assert_equal expected, @parser.parse('NTLM foo=')
-  end
-
-  def test_parse_realm_uppercase
-    expected = [
-      challenge('Basic', { 'realm' => 'foo' }, 'Basic ReAlM=foo'),
-    ]
-
-    assert_equal expected, @parser.parse('Basic ReAlM=foo')
-  end
-
-  def test_parse_realm_value_case
-    expected = [
-      challenge('Basic', { 'realm' => 'Foo' }, 'Basic realm=Foo'),
-    ]
-
-    assert_equal expected, @parser.parse('Basic realm=Foo')
-  end
-
-  def test_parse_scheme_uppercase
-    expected = [
-      challenge('Basic', { 'realm' => 'foo' }, 'BaSiC realm=foo'),
-    ]
-
-    assert_equal expected, @parser.parse('BaSiC realm=foo')
-  end
-
-  def test_parse_bad_whitespace_around_auth_param
-    expected = [
-      challenge('Basic', { 'realm' => 'foo' }, 'Basic realm = "foo"'),
-    ]
-
-    assert_equal expected, @parser.parse('Basic realm = "foo"')
-  end
-
-  def test_parse_bad_single_quote
-    expected = [
-      challenge('Basic', { 'realm' => "'foo" }, "Basic realm='foo"),
-    ]
-
-    assert_equal expected, @parser.parse("Basic realm='foo bar', qop='baz'")
-  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, raw
-    Mechanize::HTTP::AuthChallenge.new scheme, params, raw
-  end
-
-end
-

data/test/test_mechanize_image.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-require 'mechanize/test_case'
-
-class TestMechanizeImage < Mechanize::TestCase
-
-  # empty subclass, no tests
-
-end
-

data/test/test_mechanize_link.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-require 'mechanize/test_case'
-
-class TestMechanizeLink < Mechanize::TestCase
-
-  def test_search
-    page = @mech.get("http://localhost/find_link.html")
-    link = page.link_with(text: "Form Test")
-
-    assert_equal('Form Test', link.text)
-
-    link_with_search = page.link_with(search: "//*[text()='Form Test']")
-    assert_equal(link, link_with_search)
-
-    link_with_xpath = page.link_with(xpath: "//*[text()='Form Test']")
-    assert_equal(link, link_with_xpath)
-
-    link_with_css = page.link_with(css: ".formtest")
-    assert_equal(link, link_with_css)
-
-    link_with_class = page.link_with(class: "formtest")
-    assert_equal(link, link_with_class)
-  end
-
-  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 unless RUBY_ENGINE == 'jruby'  # NekoHTML does not parse body of NOFRAMES
-
-  def test_click_bang
-    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 unless RUBY_ENGINE == 'jruby'  # NekoHTML does not parse body of NOFRAMES
-
-  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
-      begin
-        link.click
-      rescue Mechanize::UnsupportedSchemeError => error
-          assert_equal 'javascript', error.scheme
-          assert_equal "javascript:new_page('1')", error.uri.to_s
-        raise
-      end
-    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_click_unexiting_link
-    page = @mech.get("http://google.com/tc_links.html")
-    assert_raises NoMethodError do
-      page.link_with(:text => 'no link').click
-    end
-    begin
-      page.link_with!(:text => 'no link').click
-    rescue => e
-      assert_instance_of Mechanize::ElementNotFoundError, e
-      assert_kind_of Mechanize::Page, e.source
-      assert_equal :link, e.element
-      assert_kind_of Hash, e.conditions
-      assert_equal 'no link', e.conditions[:text]
-    end
-  end
-
-  def test_click_empty_href
-    page = @mech.get("http://google.com/tc_links.html?q=test#anchor")
-    link = page.link_with(:text => 'empty href')
-
-    new_page = link.click
-    assert_equal "http://google.com/tc_links.html?q=test", new_page.uri.to_s
-  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 unless RUBY_ENGINE == 'jruby'  # NekoHTML does not parse IFRAME
-
-  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
-
-  def test_uri_weird_with_fragment
-    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 '%D1%83%D0%B2%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5', link.uri.fragment
-  end
-
-  def test_bad_uri_raise_compatible_exception
-    doc = Nokogiri::HTML::Document.new
-
-    node = Nokogiri::XML::Node.new('foo', doc)
-    node['href'] = 'http://http:foo.bar/ baz'
-
-    link = Mechanize::Page::Link.new(node, nil, nil)
-
-    assert_raises URI::InvalidURIError do
-      link.uri
-    end
-  end
-
-  def test_resolving_full_uri
-    page = @mech.get("http://localhost/frame_test.html")
-    link = page.link_with(:text => "Form Test")
-
-    assert_equal "/form_test.html", link.uri.to_s
-    assert_equal "http://localhost/form_test.html", link.resolved_uri.to_s
-  end unless RUBY_ENGINE == 'jruby'  # NekoHTML does not parse body of NOFRAMES
-end
-

data/test/test_mechanize_page.rb

@@ -1,295 +0,0 @@
-# frozen_string_literal: true
-require 'mechanize/test_case'
-
-class TestMechanizePage < Mechanize::TestCase
-
-  def setup
-    super
-
-    @uri = URI 'http://example/'
-  end
-
-  def test_selector_methods
-    page = html_page <<-BODY
-<html>
-  <meta>
-  <head><title></title>
-  <body>
-    <span class="name" id="out">Eamonn</span>
-    <span>/</span>
-    <span class="name" id="bloody">Esther</span>
-    <span>/</span>
-    <span class="name" id="rageous">Fletcher</span>
-  </body>
-</html>
-    BODY
-
-    # at(css_selector), % css_selector
-    assert_equal('Eamonn', page.at('#out').text)
-    assert_equal('Eamonn', (page % '#out').text)
-
-    # at(xpath_selector), % xpath_selector
-    assert_equal('Esther', page.at('//span[@id="bloody"]').text)
-    assert_equal('Esther', (page % '//span[@id="bloody"]').text)
-
-    # at_css()
-    assert_equal('Eamonn', page.at_css('#out').text)
-
-    # css()
-    assert_equal('Fletcher', page.css('.name')[2].text)
-
-    # at_xpath()
-    assert_equal('Esther', page.at_xpath('//span[@id="bloody"]').text)
-
-    # xpath()
-    assert_equal('Fletcher', page.xpath('//*[@class="name"]')[2].text)
-  end
-
-  def test_initialize_good_content_type
-    page = Mechanize::Page.new
-    assert_equal('text/html', page.content_type)
-
-    [
-      'text/html',
-      'Text/HTML',
-      'text/html; charset=UTF-8',
-      'text/html ; charset=US-ASCII',
-      'application/xhtml+xml',
-      'Application/XHTML+XML',
-      'application/xhtml+xml; charset=UTF-8',
-      'application/xhtml+xml ; charset=US-ASCII',
-    ].each { |content_type|
-      page = Mechanize::Page.new(URI('http://example/'),
-        { 'content-type' => content_type }, 'hello', '200')
-
-      assert_equal(content_type, page.content_type, content_type)
-    }
-  end
-
-  def test_initialize_bad_content_type
-    [
-      'text/xml',
-      'text/xhtml',
-      'text/htmlfu',
-      'footext/html',
-      'application/xhtml+xmlfu',
-      'fooapplication/xhtml+xml',
-    ].each { |content_type|
-      page = Mechanize::Page.new(URI('http://example/'),
-        { 'content-type' => content_type }, 'hello', '200')
-
-      assert_equal(content_type, page.content_type, 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
-
-    assert_equal %w[/google.html /file_upload.html], page.frames_with(search: '*[name=frame1], *[name=frame3]').map(&:src)
-  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 unless RUBY_ENGINE == 'jruby'  # NekoHTML does not parse IFRAME
-
-  def test_image_with
-    page = html_page <<-BODY
-<img src="a.jpg">
-<img src="b.jpg">
-<img src="c.png">
-    BODY
-
-    assert_equal "http://example/b.jpg",
-                 page.image_with(:src => 'b.jpg').url.to_s
-  end
-
-  def test_images_with
-    page = html_page <<-BODY
-<img src="a.jpg">
-<img src="b.jpg">
-<img src="c.png">
-    BODY
-
-    images = page.images_with(:src => /jpg\Z/).map { |img| img.url.to_s }
-    assert_equal %w[http://example/a.jpg http://example/b.jpg], images
-  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
-
-  def test_search_links
-    page = html_page <<-BODY
-<html>
-  <meta>
-  <head><title></title>
-  <body>
-    <span id="spany">
-      <a href="b.html">b</a>
-      <a href="a.html">a</a>
-    </span>
-    <a href="6.html">6</a>
-  </body>
-</html>
-    BODY
-
-    links = page.links_with(:search => "#spany a")
-
-    assert_equal 2, links.size
-    assert_equal "b.html", links[0].href
-    assert_equal "b",      links[0].text
-
-    assert_equal "a.html", links[1].href
-    assert_equal "a",      links[1].text
-  end
-
-  def test_search_images
-    page = html_page <<-BODY
-<html>
-  <meta>
-  <head><title></title>
-  <body>
-    <img src="1.jpg" class="unpretty">
-    <img src="a.jpg" class="pretty">
-    <img src="b.jpg">
-    <img src="c.png" class="pretty">
-  </body>
-</html>
-    BODY
-
-    {
-      :search => "//img[@class='pretty']",
-      :xpath => "//img[@class='pretty']",
-      :css => "img.pretty",
-      :class => "pretty",
-      :dom_class => "pretty",
-    }.each { |key, expr|
-      images = page.images_with(key => expr)
-
-      message = "selecting with #{key.inspect}"
-
-      assert_equal 2, images.size
-      assert_equal "pretty", images[0].dom_class, message
-      assert_equal "a.jpg", images[0].src, message
-
-      assert_equal "pretty", images[1].dom_class, message
-      assert_equal "c.png", images[1].src, message
-    }
-  end
-
-  def test_search_bad_selectors
-    page = html_page <<-BODY
-<a href="foo.html">foo</a>
-<img src="foo.jpg" />
-    BODY
-
-    assert_empty page.images_with(:search => '//a')
-    assert_empty page.links_with(:search => '//img')
-  end
-
-	def test_multiple_titles
-		page = html_page <<-BODY
-<!doctype html>
-<html>
-	<head>
-		<title>HTML&gt;TITLE</title>
-	</head>
-	<body>
-		<svg>
-			<title>SVGTITLE</title>
-			<metadata id="metadata5">
-				<rdf:RDF>
-					<cc:Work>
-						<dc:title>RDFDCTITLE</dc:title>
-					</cc:Work>
-				</rdf:RDF>
-			</metadata>
-			<g></g>
-		</svg>
-	</body>
-</html>
-		BODY
-
-		assert_equal page.title, "HTML>TITLE"
-	end
-
-  def test_frozen_string_body
-    html = (<<~HTML).freeze
-      <html>
-        <head>
-          <title>Page Title</title>
-        </head>
-        <body>
-          <p>Hello World</p>
-        </body>
-      </html>
-    HTML
-
-    html_page(html) # refute_raises
-  end
-end
-