domo 0.0.3 → 0.0.4

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

@@ -0,0 +1,13 @@
+require "helper"
+
+class TestNoAttributes < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_parse_no_attributes
+    assert_nothing_raised do
+      page = @agent.get('http://localhost/tc_no_attributes.html')
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require "helper"
+
+class OptionTest < Test::Unit::TestCase
+  class FakeAttribute < Hash
+    attr_reader :inner_text
+    def initialize(inner_text)
+      @inner_text = inner_text
+    end
+    alias :has_attribute? :has_key?
+    alias :attributes :keys
+  end
+
+  def test_option_missing_value
+    attribute = FakeAttribute.new('blah')
+    option = Mechanize::Form::Option.new(attribute, nil)
+    assert_equal('blah', option.value)
+  end
+end

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

@@ -0,0 +1,124 @@
+require "helper"
+
+require 'cgi'
+
+class TestPage < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_page_gets_charset_from_page
+    page = @agent.get("http://localhost/tc_charset.html")
+    assert_equal 'windows-1255', page.encoding
+  end
+
+  def test_double_semicolon
+    page = @agent.get("http://localhost/http_headers?content-disposition=#{CGI.escape('attachment;; filename=fooooo')}")
+    assert page.parser
+  end
+
+  def test_broken_charset
+    page = @agent.get("http://localhost/http_headers?content-type=#{CGI.escape('text/html; charset=akldsjfhaldjfksh')}")
+    assert page.parser
+  end
+
+  def test_mostly_broken_charset
+    page = @agent.get("http://localhost/http_headers?content-type=#{CGI.escape('text/html; charset=ISO_8859-1')}")
+    assert_equal 'ISO_8859-1', page.encoding
+  end
+
+  def test_another_mostly_broken_charset
+    page = @agent.get("http://localhost/http_headers?content-type=#{CGI.escape('text/html; charset=UTF8')}")
+    assert_equal 'UTF8', page.parser.encoding
+    assert_equal 'UTF8', page.encoding
+  end
+
+  def test_upper_case_content_type
+    page = @agent.get("http://localhost/http_headers?content-type=#{CGI.escape('text/HTML')}")
+    assert_instance_of Mechanize::Page, page
+    assert_equal 'text/HTML', page.content_type
+  end
+
+  def test_encoding_override_before_parser_initialized
+    # document has a bad encoding information - windows-1255
+    page = @agent.get("http://localhost/tc_bad_charset.html")
+    # encoding is wrong, so user wants to force ISO-8859-2
+    page.encoding = 'ISO-8859-2'
+    assert_equal 'ISO-8859-2', page.encoding
+  end
+
+  def test_encoding_override_after_parser_was_initialized
+    # document has a bad encoding information - windows-1255
+    page = @agent.get("http://localhost/tc_bad_charset.html")
+    page.parser
+    # autodetection sets encoding to windows-1255
+    assert_equal 'windows-1255', page.encoding
+    # encoding is wrong, so user wants to force ISO-8859-2
+    page.encoding = 'ISO-8859-2'
+    assert_equal 'ISO-8859-2', page.encoding
+  end
+
+  def test_page_gets_charset_sent_by_server
+    page = @agent.get("http://localhost/http_headers?content-type=#{CGI.escape('text/html; charset=UTF-8')}")
+    assert_equal 'UTF-8', page.encoding
+  end
+
+  def test_page_gets_charset_sent_by_server_with_trailing_semicolon
+    page = @agent.get("http://localhost/http_headers?content-type=#{CGI.escape('text/html; charset=UTF-8;')}")
+    assert_equal 'UTF-8', page.encoding
+  end
+
+  def test_set_encoding
+    page = @agent.get("http://localhost/file_upload.html")
+    page.encoding = 'UTF-8'
+    assert_equal 'UTF-8', page.parser.encoding
+  end
+
+  def test_page_gets_yielded
+    pages = nil
+    @agent.get("http://localhost/file_upload.html") { |page|
+      pages = page
+    }
+    assert pages
+    assert_equal('File Upload Form', pages.title)
+  end
+
+  def test_title
+    page = @agent.get("http://localhost/file_upload.html")
+    assert_equal('File Upload Form', page.title)
+  end
+
+  def test_no_title
+    page = @agent.get("http://localhost/no_title_test.html")
+    assert_equal(nil, page.title)
+  end
+
+  def test_page_decoded_with_charset
+    page = Mechanize::Page.new(
+      URI.parse('http://tenderlovemaking.com/'),
+      { 'content-type' => 'text/html; charset=EUC-JP' },
+      '<html><body>hello</body></html>',
+      400,
+      @agent
+    )
+    assert_equal 'EUC-JP', page.parser.encoding
+  end
+
+  def test_find_form_with_hash
+    page  = @agent.get("http://localhost/tc_form_action.html")
+    form = page.form(:name => 'post_form1')
+    assert form
+    yielded = false
+    form = page.form(:name => 'post_form1') { |f|
+      yielded = true
+      assert f
+      assert_equal(form, f)
+    }
+    assert yielded
+
+    form_by_action = page.form(:action => '/form_post?a=b&b=c')
+    assert form_by_action
+    assert_equal(form, form_by_action)
+  end
+end
+

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

@@ -0,0 +1,145 @@
+require "helper"
+
+class PluggableParserTest < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_content_type_error
+    page = @agent.get("http://localhost/bad_content_type")
+    assert_raise(Mechanize::ContentTypeError) {
+      page = Mechanize::Page.new(
+                                      page.uri, 
+                                      page.response, 
+                                      page.body,
+                                      page.code
+                                     )
+    }
+    begin
+      page = Mechanize::Page.new(
+                                      page.uri, 
+                                      page.response, 
+                                      page.body,
+                                      page.code
+                                     )
+    rescue Mechanize::ContentTypeError => ex
+      assert_equal('text/xml', ex.content_type)
+    end
+  end
+
+  def test_content_type
+    page = @agent.get("http://localhost/content_type_test")
+    assert_kind_of(Mechanize::Page, page)
+  end
+
+  class Filter < Mechanize::Page
+    def initialize(uri=nil, response=nil, body=nil, code=nil)
+      super(  uri,
+            response,
+            body.gsub(/<body>/, '<body><a href="http://daapclient.rubyforge.org">Net::DAAP::Client</a>'),
+            code
+           )
+    end
+  end
+
+  class FileFilter < Mechanize::File
+    def initialize(uri=nil, response=nil, body=nil, code=nil)
+      super(  uri,
+            response,
+            body.gsub(/<body>/, '<body><a href="http://daapclient.rubyforge.org">Net::DAAP::Client</a>'),
+            code
+           )
+    end
+  end
+
+  def test_filter
+    @agent.pluggable_parser.html = Filter
+    page = @agent.get("http://localhost/find_link.html")
+    assert_kind_of(Filter, page)
+    assert_equal(19, page.links.length)
+    assert_not_nil(page.link_with(:text => 'Net::DAAP::Client'))
+    assert_equal(1, page.links_with(:text => 'Net::DAAP::Client').length)
+  end
+
+  def test_filter_hash
+    @agent.pluggable_parser['text/html'] = Filter
+    page = @agent.get("http://localhost/find_link.html")
+    assert_kind_of(Class, @agent.pluggable_parser['text/html'])
+    assert_equal(Filter, @agent.pluggable_parser['text/html'])
+    assert_kind_of(Filter, page)
+    assert_equal(19, page.links.length)
+    assert_not_nil(page.link_with(:text => 'Net::DAAP::Client'))
+    assert_equal(1, page.links_with(:text => 'Net::DAAP::Client').length)
+  end
+
+  def test_file_saver
+    @agent.pluggable_parser.html = Mechanize::FileSaver
+    page = @agent.get('http://localhost:2000/form_no_action.html')
+    length = page.response['Content-Length']
+    file_length = nil
+    File.open("localhost/form_no_action.html", "r") { |f|
+      file_length = f.read.length
+    }
+    FileUtils.rm_rf("localhost")
+    assert_equal(length.to_i, file_length)
+  end
+
+  def test_content_type_pdf
+    @agent.pluggable_parser.pdf = FileFilter
+    page = @agent.get("http://localhost/content_type_test?ct=application/pdf")
+    assert_kind_of(Class, @agent.pluggable_parser['application/pdf'])
+    assert_equal(FileFilter, @agent.pluggable_parser['application/pdf'])
+    assert_kind_of(FileFilter, page)
+  end
+
+  def test_content_type_csv
+    @agent.pluggable_parser.csv = FileFilter
+    page = @agent.get("http://localhost/content_type_test?ct=text/csv")
+    assert_kind_of(Class, @agent.pluggable_parser['text/csv'])
+    assert_equal(FileFilter, @agent.pluggable_parser['text/csv'])
+    assert_kind_of(FileFilter, page)
+  end
+
+  def test_content_type_xml
+    @agent.pluggable_parser.xml = FileFilter
+    page = @agent.get("http://localhost/content_type_test?ct=text/xml")
+    assert_kind_of(Class, @agent.pluggable_parser['text/xml'])
+    assert_equal(FileFilter, @agent.pluggable_parser['text/xml'])
+    assert_kind_of(FileFilter, page)
+  end
+
+  def test_file_saver_no_path
+    url = URI::HTTP.new('http', nil, 'example.com', nil, nil, '', nil, nil, nil)
+    fs = Mechanize::FileSaver.new(url, nil, 'hello world', 200)
+    assert_equal('example.com/index.html', fs.filename)
+    FileUtils.rm_rf('example.com')
+  end
+
+  def test_file_saver_slash
+    url = URI::HTTP.new('http', nil, 'example.com', nil, nil, '/', nil, nil, nil)
+    fs = Mechanize::FileSaver.new(url, nil, 'hello world', 200)
+    assert_equal('example.com/index.html', fs.filename)
+    FileUtils.rm_rf('example.com')
+  end
+
+  def test_file_saver_slash_file
+    url = URI::HTTP.new('http', nil, 'example.com', nil, nil, '/foo.html', nil, nil, nil)
+    fs = Mechanize::FileSaver.new(url, nil, 'hello world', 200)
+    assert_equal('example.com/foo.html', fs.filename)
+    FileUtils.rm_rf('example.com')
+  end
+
+  def test_file_saver_long_path_no_file
+    url = URI::HTTP.new('http', nil, 'example.com', nil, nil, '/one/two/', nil, nil, nil)
+    fs = Mechanize::FileSaver.new(url, nil, 'hello world', 200)
+    assert_equal('example.com/one/two/index.html', fs.filename)
+    FileUtils.rm_rf('example.com')
+  end
+
+  def test_file_saver_long_path
+    url = URI::HTTP.new('http', nil, 'example.com', nil, nil, '/one/two/foo.html', nil, nil, nil)
+    fs = Mechanize::FileSaver.new(url, nil, 'hello world', 200)
+    assert_equal('example.com/one/two/foo.html', fs.filename)
+    FileUtils.rm_rf('example.com')
+  end
+end

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

@@ -0,0 +1,34 @@
+require "helper"
+
+class PostForm < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_post_form
+    page = @agent.post("http://localhost/form_post",
+                        'gender' => 'female'
+                      )
+    assert_not_nil(
+      page.links.find { |l| l.text == "gender:female" },
+      "gender field missing"
+    )
+  end
+
+  def test_post_form_multival
+    page = @agent.post("http://localhost/form_post",
+                       [ ['gender', 'female'],
+                         ['gender', 'male']
+                       ]
+                      )
+    assert_not_nil(
+      page.links.find { |l| l.text == "gender:female" },
+      "gender field missing"
+    )
+    assert_not_nil(
+      page.links.find { |l| l.text == "gender:male" },
+      "gender field missing"
+    )
+    assert_equal(2, page.links.length)
+  end
+end

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

@@ -0,0 +1,22 @@
+require "helper"
+
+class TestPrettyPrint < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+  
+  def test_pretty_print
+    @agent.get("http://localhost/tc_pretty_print.html")
+    pretty_string = @agent.pretty_print_inspect
+    assert_match("{title \"tc_pretty_print.html\"}", pretty_string)
+    assert_match(/\{frames[^"]*"http:\/\/meme/, pretty_string)
+    assert_match(/\{iframes[^"]*"http:\/\/meme/, pretty_string)
+    assert_match(
+     "{links #<Mechanize::Page::Link \"Google\" \"http://google.com/\">}",
+     pretty_string
+                )
+    assert_match("form1", pretty_string)
+    assert_match("POST", pretty_string)
+    assert_match("{file_uploads}", pretty_string)
+  end
+end

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

@@ -0,0 +1,75 @@
+require "helper"
+
+class TestRadioButtons < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+    @page  = @agent.get("http://localhost/tc_radiobuttons.html")
+  end
+
+  def test_select_all
+    form = @page.forms.first
+    form.radiobuttons_with(:name => 'color').each do |b|
+      b.check
+    end
+    form.radiobutton_with(:name => 'color', :value => 'green').check
+
+    assert_equal(true, form.radiobutton_with( :name => 'color',
+                                              :value => 'green').checked)
+
+    %w{ red blue yellow brown }.each do |button_value|
+      assert_equal(false, form.radiobutton_with(  :name => 'color',
+                                                  :value => button_value
+                                               ).checked)
+    end
+  end
+
+  def test_unselect_all
+    form = @page.forms.first
+    form.radiobuttons_with(:name => 'color').each do |b|
+      b.uncheck
+    end
+    %w{ green red blue yellow brown }.each do |button_value|
+      assert_equal(false, form.radiobutton_with(  :name => 'color',
+                                                  :value => button_value
+                                               ).checked)
+    end
+  end
+
+  def test_click_one
+    form = @page.forms.first
+    form.radiobutton_with(:name => 'color', :value => 'green').click
+
+    assert form.radiobutton_with(:name => 'color', :value => 'green').checked
+
+    %w{ red blue yellow brown }.each do |button_value|
+      assert_equal(false, form.radiobutton_with(  :name => 'color',
+                                                  :value => button_value
+                                               ).checked)
+    end
+  end
+
+  def test_click_twice
+    form = @page.forms.first
+    form.radiobutton_with(:name => 'color', :value => 'green').click
+    assert form.radiobutton_with(:name => 'color', :value => 'green').checked
+
+    form.radiobutton_with(:name => 'color', :value => 'green').click
+    %w{ green red blue yellow brown }.each do |button_value|
+      assert_equal(false, form.radiobutton_with(  :name => 'color',
+                                                  :value => button_value
+                                               ).checked)
+    end
+  end
+
+  def test_click_all
+    form = @page.forms.first
+    form.radiobuttons_with(:name => 'color').each do |button|
+      button.click
+    end
+    c = form.radiobuttons_with(:name => 'color').inject(0) do |m,button|
+      m += 1 if button.checked
+      m
+    end
+    assert_equal 1, c, 'Only one radio button should be checked'
+  end
+end

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

@@ -0,0 +1,39 @@
+require "helper"
+
+class TestRedirectLimitReached < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_to_s
+    page = MechTestHelper.fake_page(@agent)
+    error = Mechanize::RedirectLimitReachedError.new(page, 10)
+    assert_match(/10/, error.to_s)
+  end
+
+  def test_get_default_redirects
+    assert_raises(Mechanize::RedirectLimitReachedError) {
+      begin
+        @agent.get('http://localhost/infinite_redirect')
+      rescue Mechanize::RedirectLimitReachedError => ex
+        assert_equal(@agent.redirection_limit, ex.redirects)
+        assert_equal("q=#{@agent.redirection_limit}", ex.page.uri.query)
+        raise ex
+      end
+    }
+  end
+
+  def test_get_2_redirects
+    @agent.redirection_limit = 2
+    assert_raises(Mechanize::RedirectLimitReachedError) {
+      begin
+        @agent.get('http://localhost/infinite_redirect')
+      rescue Mechanize::RedirectLimitReachedError => ex
+        assert_equal(2, ex.redirects)
+        assert_equal(@agent.redirection_limit, ex.redirects)
+        assert_equal("q=#{@agent.redirection_limit}", ex.page.uri.query)
+        raise ex
+      end
+    }
+  end
+end