domo 0.0.3 → 0.0.4

data/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/test/test_frames.rb

@@ -0,0 +1,25 @@
+require "helper"
+
+class FramesMechTest < Test::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)
+  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)
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/test/test_get_headers.rb

@@ -0,0 +1,52 @@
+require "helper"
+
+class TestGetHeaders < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_bad_header_symbol
+    assert_raises(ArgumentError) do
+      @agent.get(:url => "http://localhost/file_upload.html", :headers => { :foobar => "is fubar"})
+    end
+  end
+
+  def test_host_header
+    page = @agent.get(:url => 'http://localhost/http_headers', :headers => { :etag => '160604-24bc-9fe2c40'})
+    assert_header(page, 'host' => 'localhost')
+  end
+
+  def test_etag_header
+    page = @agent.get(:url => 'http://localhost/http_headers', :headers => { :etag => '160604-24bc-9fe2c40'})
+    assert_header(page, 'etag' => '160604-24bc-9fe2c40')
+  end
+
+  def test_if_modified_since_header
+    value = (Time.now - 600).strftime("%a, %d %b %Y %H:%M:%S %z")
+    page = @agent.get(:url => 'http://localhost/http_headers', :headers => { :if_modified_since => value})
+    assert_header(page, 'if-modified-since' => value)
+  end
+
+  def test_if_modified_since_response
+    value = (Time.now - 600).strftime("%a, %d %b %Y %H:%M:%S %z")
+    page = @agent.get(:url => 'http://localhost/if_modified_since', :headers => { :if_modified_since => value})
+    assert_equal "304", page.code
+    assert_equal "0", page.header['content-length']
+  end
+
+  def test_string_header
+    page = @agent.get(:url => 'http://localhost/http_headers', :headers => { "X-BS-French-Header" => 'Ou est la bibliotheque?'})
+    assert_header(page, 'x-bs-french-header' => 'Ou est la bibliotheque?')
+  end
+
+  def assert_header(page, header)
+    headers = {}
+    page.body.split(/[\r\n]+/).each do |page_header|
+      headers.[]=(*page_header.chomp.split(/\|/))
+    end
+    header.each do |key, value|
+      assert(headers.has_key?(key))
+      assert_equal(value, headers[key])
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/test/test_gzipping.rb

@@ -0,0 +1,22 @@
+require "helper"
+
+class TestGzip < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_request_empty_gzip
+    assert_nothing_raised do
+      page = @agent.get("http://localhost/gzip")
+    end
+  end
+
+  def test_request_gzip
+    page = nil
+    assert_nothing_raised do
+      page = @agent.get("http://localhost/gzip?file=index.html")
+    end
+    assert_kind_of(Mechanize::Page, page)
+    assert_match('Hello World', page.body)
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/test/test_hash_api.rb

@@ -0,0 +1,45 @@
+require "helper"
+
+class TestHashApi < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_title
+    page = @agent.get(:url => "http://localhost/file_upload.html")
+    assert_equal('File Upload Form', page.title)
+  end
+
+  def test_page_gets_yielded
+    pages = nil
+    @agent.get(:url => "http://localhost/file_upload.html") { |page|
+      pages = page
+    }
+    assert pages
+    assert_equal('File Upload Form', pages.title)
+  end
+
+  def test_get_with_params
+    page = @agent.get(:url => 'http://localhost/', :params => { :q => 'hello' })
+    assert_equal('http://localhost/?q=hello', page.uri.to_s)
+  end
+
+  def test_get_with_referer
+    request = nil
+    @agent.pre_connect_hooks << lambda { |params|
+      request = params[:request]
+    }
+
+    @agent.get( :url => 'http://localhost/',
+                :referer => URI.parse('http://google.com/')
+              )
+
+    assert request
+    assert_equal 'http://google.com/', request['Referer']
+
+    @agent.get( :url => 'http://localhost/',
+                :params => [],
+                :referer => 'http://tenderlovemaking.com/')
+    assert_equal 'http://tenderlovemaking.com/', request['Referer']
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/test/test_history.rb

@@ -0,0 +1,142 @@
+require "helper"
+
+class TestHistory < Test::Unit::TestCase
+  def setup
+    @agent    = Mechanize.new
+    @history  = Mechanize::History.new
+  end
+
+  def test_push
+    assert_equal(0, @history.length)
+
+    page = @agent.get("http://localhost/tc_bad_links.html")
+    x = @history.push(page)
+    assert_equal(x, @history)
+    assert_equal(1, @history.length)
+    assert(@history.visited?(page))
+    assert(@history.visited?(page.uri))
+    assert(@history.visited?(page.uri.to_s))
+    assert_equal(page, @history.visited_page(page))
+    assert_equal(page, @history.visited_page(page.uri))
+    assert_equal(page, @history.visited_page(page.uri.to_s))
+
+    @history.push(@agent.get("/tc_bad_links.html"))
+    assert_equal(2, @history.length)
+  end
+
+  def test_shift
+    assert_equal(0, @history.length)
+    page = @agent.get("http://localhost/tc_bad_links.html")
+    @history.push(page)
+    assert_equal(1, @history.length)
+
+    @history.push(@agent.get("/tc_bad_links.html"))
+    assert_equal(2, @history.length)
+
+    @history.push(@agent.get("/index.html"))
+    assert_equal(3, @history.length)
+
+    page2 = @history.shift
+    assert_equal(page, page2)
+    assert_equal(2, @history.length)
+
+    @history.shift
+    assert_equal(1, @history.length)
+    assert_equal(false, @history.visited?(page))
+
+    @history.shift
+    assert_equal(0, @history.length)
+
+    assert_nil(@history.shift)
+    assert_equal(0, @history.length)
+  end
+
+  def test_pop
+    assert_equal(0, @history.length)
+    page = @agent.get("http://localhost/tc_bad_links.html")
+    @history.push(page)
+    assert_equal(1, @history.length)
+
+    page2 = @agent.get("/index.html")
+    @history.push(page2)
+    assert_equal(2, @history.length)
+    assert_equal(page2, @history.pop)
+    assert_equal(1, @history.length)
+    assert_equal(true, @history.visited?(page))
+    assert_equal(false, @history.visited?(page2))
+    assert_equal(page, @history.pop)
+    assert_equal(0, @history.length)
+    assert_equal(false, @history.visited?(page))
+    assert_equal(false, @history.visited?(page2))
+    assert_nil(@history.pop)
+  end
+
+  def test_max_size
+    @history  = Mechanize::History.new(10)
+    1.upto(20) do |i|
+      page = @agent.get('http://localhost/index.html')
+      @history.push page
+      assert_equal(true, @history.visited?(page))
+      if i < 10
+        assert_equal(i, @history.length)
+      else
+        assert_equal(10, @history.length)
+      end
+    end
+
+    @history.clear
+    @history.max_size = 5
+    1.upto(20) do |i|
+      page = @agent.get('http://localhost/index.html')
+      @history.push page
+      assert_equal(true, @history.visited?(page))
+      if i < 5
+        assert_equal(i, @history.length)
+      else
+        assert_equal(5, @history.length)
+      end
+    end
+
+    @history.max_size = 0
+    1.upto(20) do |i|
+      page = @agent.get('http://localhost/index.html')
+      @history.push page
+      assert_equal(false, @history.visited?(page))
+      assert_equal(0, @history.length)
+    end
+  end
+
+  def test_no_slash
+    page = @agent.get('http://localhost')
+
+    node = Struct.new(:href, :inner_text).new('http://localhost/', 'blah')
+    link = Mechanize::Page::Link.new(node, nil, nil)
+    assert(@agent.visited?(link))
+
+    node = Struct.new(:href, :inner_text).new('http://localhost', 'blah')
+    link = Mechanize::Page::Link.new(node, nil, nil)
+    assert(@agent.visited?(link))
+  end
+
+  def test_with_slash
+    page = @agent.get('http://localhost/')
+
+    node = Struct.new(:href, :inner_text).new('http://localhost/', 'blah')
+    link = Mechanize::Page::Link.new(node, nil, nil)
+    assert(@agent.visited?(link))
+
+    node = Struct.new(:href, :inner_text).new('http://localhost', 'blah')
+    link = Mechanize::Page::Link.new(node, nil, nil)
+    assert(@agent.visited?(link))
+  end
+
+  def test_clear
+    page = nil
+    20.times { @history.push(page = @agent.get('http://localhost/index.html')) }
+    assert_equal(20, @history.length)
+    assert_equal(true, @history.visited?(page))
+    @history.clear
+    assert_equal(0, @history.length)
+    assert_equal(false, @history.visited?(page))
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/test/test_history_added.rb

@@ -0,0 +1,16 @@
+require "helper"
+
+class HistoryAddedTest < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_history_added_gets_called
+    onload = 0
+    @agent.history_added = lambda { |page|
+      onload += 1
+    }
+    page = @agent.get('http://localhost/tc_blank_form.html')
+    assert_equal(1, onload)
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/test/test_html_unscape_forms.rb

@@ -0,0 +1,46 @@
+require "helper"
+
+class TestCheckBoxes < Test::Unit::TestCase
+  def test_field
+    f = Mechanize::Form::Field.new({'name' => 'a&amp;b'}, 'a&amp;b')
+    assert_equal('a&b', f.name)
+    assert_equal('a&b', f.value)
+
+    f = Mechanize::Form::Field.new({'name' => 'a&b'}, 'a&b')
+    assert_equal('a&b', f.name)
+    assert_equal('a&b', f.value)
+
+    f = Mechanize::Form::Field.new({'name' => 'a&#38;b'}, 'a&#38;b')
+    assert_equal('a&b', f.name)
+    assert_equal('a&b', f.value)
+  end
+
+  def test_file_upload
+    f = Mechanize::Form::FileUpload.new(fake_node, 'a&amp;b')
+    assert_equal('a&b', f.name)
+    assert_equal('a&b', f.file_name)
+
+    f = Mechanize::Form::FileUpload.new(fake_node, 'a&b')
+    assert_equal('a&b', f.name)
+    assert_equal('a&b', f.file_name)
+  end
+
+  def test_image_button
+    f = Mechanize::Form::ImageButton.new({'name' => 'a&amp;b'}, 'a&amp;b')
+    assert_equal('a&b', f.name)
+    assert_equal('a&b', f.value)
+  end
+
+  def test_radio_button
+    f = Mechanize::Form::RadioButton.new(fake_node, nil)
+    assert_equal('a&b', f.name)
+    assert_equal('a&b', f.value)
+  end
+
+  def fake_node
+    {
+      'name'  => 'a&amp;b',
+      'value' => 'a&amp;b'
+    }
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/test/test_if_modified_since.rb

@@ -0,0 +1,20 @@
+require "helper"
+
+class TestIfModifiedSince < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_get_twice
+    assert_equal(0, @agent.history.length)
+    page = @agent.get('http://localhost/if_modified_since')
+    assert_match(/You did not send/, page.body)
+
+    assert_equal(1, @agent.history.length)
+    page2 = @agent.get('http://localhost/if_modified_since')
+
+    assert_equal(2, @agent.history.length)
+    assert_equal(page.object_id, page2.object_id)
+    assert_match(/You did not send/, page.body)
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/test/test_keep_alive.rb

@@ -0,0 +1,31 @@
+require "helper"
+
+class TestKeepAlive < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_keep_alive
+    page = @agent.get('http://localhost/http_headers')
+    headers = {}
+    page.body.split(/[\r\n]+/).each do |header|
+      headers.[]=(*header.chomp.split(/\|/))
+    end
+    assert(headers.has_key?('connection'))
+    assert_equal('keep-alive', headers['connection'])
+    assert(headers.has_key?('keep-alive'))
+    assert_equal('300', headers['keep-alive'])
+  end
+
+  def test_close_connection
+    @agent.keep_alive = false
+    page = @agent.get('http://localhost/http_headers')
+    headers = {}
+    page.body.split(/[\r\n]+/).each do |header|
+      headers.[]=(*header.chomp.split(/\|/))
+    end
+    assert(headers.has_key?('connection'))
+    assert_equal('close', headers['connection'])
+    assert(!headers.has_key?('keep-alive'))
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/test/test_links.rb

@@ -0,0 +1,128 @@
+require "helper"
+
+class LinksMechTest < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_weird_uri
+    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_unsupported_link_types
+    page = @agent.get("http://google.com/tc_links.html")
+    link = page.link_with(:text => 'javascript link')
+    assert_raise(Mechanize::UnsupportedSchemeError) {
+      link.click
+    }
+
+    @agent.scheme_handlers['javascript'] = lambda { |my_link, my_page|
+      URI.parse('http://localhost/tc_links.html')
+    }
+    assert_nothing_raised {
+      link.click
+    }
+  end
+
+  def test_link_with_no_path
+    page = @agent.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_base
+    page = @agent.get("http://google.com/tc_base_link.html")
+    page = page.links.first.click
+    assert @agent.visited?("http://localhost/index.html")
+  end
+
+  def test_find_meta
+    page = @agent.get("http://localhost/find_link.html")
+    assert_equal(3, page.meta.length)
+    assert_equal(%w{
+      http://www.drphil.com/
+      http://www.upcase.com/
+      http://tenderlovemaking.com/ }.sort,
+      page.meta.map { |x| x.href.downcase }.sort)
+  end
+
+  def test_find_link
+    page = @agent.get("http://localhost/find_link.html")
+    assert_equal(18, page.links.length)
+  end
+
+  def test_alt_text
+    page = @agent.get("http://localhost/alt_text.html")
+    assert_equal(5, page.links.length)
+    assert_equal(1, page.meta.length)
+
+    assert_equal('', page.meta.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_click_link
+    @agent.user_agent_alias = 'Mac Safari'
+    page = @agent.get("http://localhost/frame_test.html")
+    link = page.link_with(:text => "Form Test")
+    assert_not_nil(link)
+    assert_equal('Form Test', link.text)
+    page = @agent.click(link)
+    assert_equal("http://localhost/form_test.html",
+      @agent.history.last.uri.to_s)
+  end
+
+  def test_click_method
+    page = @agent.get("http://localhost/frame_test.html")
+    link = page.link_with(:text => "Form Test")
+    assert_not_nil(link)
+    assert_equal('Form Test', link.text)
+    page = link.click
+    assert_equal("http://localhost/form_test.html",
+      @agent.history.last.uri.to_s)
+  end
+
+  def test_find_bold_link
+    page = @agent.get("http://localhost/tc_links.html")
+    link = page.links_with(:text => /Bold Dude/)
+    assert_equal(1, link.length)
+    assert_equal('Bold Dude', link.first.text)
+
+    link = page.links_with(:text => 'Aaron James Patterson')
+    assert_equal(1, link.length)
+    assert_equal('Aaron James Patterson', link.first.text)
+
+    link = page.links_with(:text => 'Aaron Patterson')
+    assert_equal(1, link.length)
+    assert_equal('Aaron Patterson', link.first.text)
+
+    link = page.links_with(:text => 'Ruby Rocks!')
+    assert_equal(1, link.length)
+    assert_equal('Ruby Rocks!', link.first.text)
+  end
+
+  def test_link_with_encoded_space
+    page = @agent.get("http://localhost/tc_links.html")
+    link = page.link_with(:text => 'encoded space')
+    page = @agent.click link
+  end
+
+  def test_link_with_space
+    page = @agent.get("http://localhost/tc_links.html")
+    link = page.link_with(:text => 'not encoded space')
+    page = @agent.click link
+  end
+
+  def test_link_with_unusual_characters
+    page = @agent.get("http://localhost/tc_links.html")
+    link = page.link_with(:text => 'unusual characters')
+    assert_nothing_raised { @agent.click link }
+  end
+end