RubyGems - husc - Versions diffs - 0.2.1 → 0.2.2 - Mend

husc 0.2.1 → 0.2.2

Files changed (1019) hide show

data/vendor/bundle/gems/mechanize-2.7.6/test/test_mechanize_link.rb DELETED Viewed

@@ -1,146 +0,0 @@
-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_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/vendor/bundle/gems/mechanize-2.7.6/test/test_mechanize_page.rb DELETED Viewed

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

data/vendor/bundle/gems/mechanize-2.7.6/test/test_mechanize_page_encoding.rb DELETED Viewed

@@ -1,187 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'mechanize/test_case'
-# tests for Page encoding and charset and parsing
-class TestMechanizePageEncoding < Mechanize::TestCase
-  MECH_ASCII_ENCODING = 'US-ASCII'
-  def setup
-    super
-    @uri = URI('http://localhost/')
-    @response_headers = { 'content-type' => 'text/html' }
-    @body = '<title>hi</title>'
-  end
-  def util_page body = @body, headers = @response_headers
-    Mechanize::Page.new @uri, headers, body && body.force_encoding(Encoding::BINARY), 200, @mech
-  end
-  def test_page_charset
-    charset = Mechanize::Page.charset 'text/html;charset=vAlue'
-    assert_equal 'vAlue', charset
-    charset = Mechanize::Page.charset 'text/html;charset=vaLue, text/html'
-    assert_equal 'vaLue', charset
-    charset = Mechanize::Page.charset 'text/html ; charset = valUe, text/html'
-    assert_equal 'valUe', charset
-  end
-  def test_page_charset_upcase
-    charset = Mechanize::Page.charset 'TEXT/HTML;CHARSET=UTF-8'
-    assert_equal 'UTF-8', charset
-  end
-  def test_page_charset_semicolon
-    charset = Mechanize::Page.charset 'text/html;charset=UTF-8;'
-    assert_equal 'UTF-8', charset
-  end
-  def test_page_charset_no_chaset_token
-    charset = Mechanize::Page.charset 'text/html'
-    assert_nil charset
-  end
-  def test_page_charset_returns_nil_when_charset_says_none
-    charset = Mechanize::Page.charset 'text/html;charset=none'
-    assert_nil charset
-  end
-  def test_page_charset_multiple
-    charset = Mechanize::Page.charset 'text/html;charset=111;charset=222'
-    assert_equal '111', charset
-  end
-  def test_page_response_header_charset
-    headers = { 'content-type' => 'text/html;charset=HEADER' }
-    charsets = Mechanize::Page.response_header_charset(headers)
-    assert_equal ['HEADER'], charsets
-  end
-  def test_page_response_header_charset_no_token
-    headers = {'content-type' => 'text/html'}
-    charsets = Mechanize::Page.response_header_charset(headers)
-    assert_equal [], charsets
-    headers = {'X-My-Header' => 'hello'}
-    charsets = Mechanize::Page.response_header_charset(headers)
-    assert_equal [], charsets
-  end
-  def test_page_response_header_charset_wrong_header
-    headers = { 'x-content-type' => 'text/html;charset=bogus' }
-    charsets = Mechanize::Page.response_header_charset(headers)
-    assert_equal [], charsets
-  end
-  def test_response_header_charset
-    page = util_page nil, {'content-type' => 'text/html;charset=HEADER'}
-    assert_equal ['HEADER'], page.response_header_charset
-  end
-  def test_page_meta_charset
-    body = '<meta http-equiv="content-type" content="text/html;charset=META">'
-    charsets = Mechanize::Page.meta_charset(body)
-    assert_equal ['META'], charsets
-  end
-  def test_page_meta_charset_is_empty_when_no_charset_meta
-    body = '<meta http-equiv="refresh" content="5; url=index.html">'
-    charsets = Mechanize::Page.meta_charset(body)
-    assert_equal [], charsets
-  end
-  def test_page_meta_charset_no_content
-    body = '<meta http-equiv="content-type">'
-    charsets = Mechanize::Page.meta_charset(body)
-    assert_empty charsets
-  end
-  # Test to fix issue: https://github.com/sparklemotion/mechanize/issues/143
-  def test_page_meta_charset_handles_whitespace
-    body = '<meta http-equiv = "Content-Type" content = "text/html; charset=iso-8859-1">'
-    charsets = Mechanize::Page.meta_charset(body)
-    assert_equal ["iso-8859-1"], charsets
-  end
-  def test_meta_charset
-    body = '<meta http-equiv="content-type" content="text/html;charset=META">'
-    page = util_page body
-    assert_equal ['META'], page.meta_charset
-  end
-  def test_detected_encoding
-    page = util_page
-    assert_equal MECH_ASCII_ENCODING, page.detected_encoding
-  end
-  def test_encodings
-    response = {'content-type' => 'text/html;charset=HEADER'}
-    body = '<meta http-equiv="content-type" content="text/html;charset=META">'
-    @mech.default_encoding = 'DEFAULT'
-    page = util_page body, response
-    assert_equal true, page.encodings.include?('HEADER')
-    assert_equal true, page.encodings.include?('META')
-    assert_equal true, page.encodings.include?(MECH_ASCII_ENCODING)
-    assert_equal true, page.encodings.include?('DEFAULT')
-  end
-  def test_parser_with_default_encoding
-    # pre test
-    assert_equal false, util_page.encodings.include?('Windows-1252')
-    @mech.default_encoding = 'Windows-1252'
-    page = util_page
-    assert_equal true, page.encodings.include?('Windows-1252')
-  end
-  def test_parser_force_default_encoding
-    @mech.default_encoding = 'Windows-1252'
-    @mech.force_default_encoding = true
-    page = util_page
-    assert page.encodings.include? 'Windows-1252'
-  end
-  def test_parser_encoding_equals_overwrites_force_default_encoding
-    @mech.default_encoding = 'Windows-1252'
-    @mech.force_default_encoding = true
-    page = util_page
-    assert_equal 'Windows-1252', page.encoding
-    page.encoding = 'ISO-8859-2'
-    assert_equal 'ISO-8859-2', page.encoding
-  end
-  def test_parser_encoding_when_searching_elements
-    skip "Encoding not implemented" unless have_encoding?
-    body = '<span id="latin1">hi</span>'
-    page = util_page body, 'content-type' => 'text/html,charset=ISO-8859-1'
-    result = page.search('#latin1')
-    assert_equal Encoding::UTF_8, result.text.encoding
-  end
-end

data/vendor/bundle/gems/mechanize-2.7.6/test/test_mechanize_page_frame.rb DELETED Viewed

@@ -1,16 +0,0 @@
-require 'mechanize/test_case'
-class TestMechanizePageFrame < Mechanize::TestCase
-  def test_content
-    page = page 'http://example/referer'
-    frame = node 'frame', 'name' => 'frame1', 'src' => 'http://example/'
-    frame = Mechanize::Page::Frame.new frame, @mech, page
-    frame.content
-    assert_equal 'http://example/referer', requests.first['Referer']
-  end
-end