domo 0.0.4 → 0.0.5

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

@@ -1,48 +0,0 @@
-require 'webrick'
-require 'webrick/https'
-require 'servlets'
-require 'logger'
-
-base_dir = FileTest.exists?(Dir::pwd + '/test') ? Dir::pwd + '/test' : Dir::pwd
-
-s = WEBrick::HTTPServer.new(
-  :Port           => 2002,
-  :DocumentRoot   => base_dir + "/htdocs",
-  :SSLEnable      => true,
-  :SSLVerifyClient  => OpenSSL::SSL::VERIFY_NONE,
-  :SSLCertificate => OpenSSL::X509::Certificate.new(
-                                  File.read("data/server.crt")
-                       ),
-  :SSLPrivateKey    => OpenSSL::PKey::RSA.new(
-                                  File.read("data/server.pem")
-                       ),
-  :Logger         => Logger.new(nil),
-  :AccessLog      => Logger.new(nil)
-)
-s.mount("/one_cookie", OneCookieTest)
-s.mount("/one_cookie_no_space", OneCookieNoSpacesTest)
-s.mount("/many_cookies", ManyCookiesTest)
-s.mount("/many_cookies_as_string", ManyCookiesAsStringTest)
-s.mount("/send_cookies", SendCookiesTest)
-s.mount("/form_post", FormTest)
-s.mount("/form post", FormTest)
-s.mount("/response_code", ResponseCodeTest)
-s.mount("/file_upload", FileUploadTest)
-s.mount("/bad_content_type", BadContentTypeTest)
-s.mount("/content_type_test", ContentTypeTest)
-
-htpasswd = WEBrick::HTTPAuth::Htpasswd.new(base_dir + '/data/htpasswd')
-auth = WEBrick::HTTPAuth::BasicAuth.new(
-  :UserDB => htpasswd,
-  :Realm  => 'mechanize',
-  :Logger         => Logger.new(nil),
-  :AccessLog      => Logger.new(nil)
-)
-s.mount_proc('/htpasswd_auth') { |req, res|
-  auth.authenticate(req, res)
-  res.body = "You are authenticated"
-}
-
-trap("INT") { s.stop }
-
-s.start

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

@@ -1,71 +0,0 @@
-require "helper"
-require 'pp'
-
-class BasicAuthTest < Test::Unit::TestCase
-  def setup
-    @agent = Mechanize.new
-  end
-
-  def test_auth_success
-    @agent.basic_auth('user', 'pass')
-    page = @agent.get("http://localhost/basic_auth")
-    assert_equal('You are authenticated', page.body)
-  end
-
-  def test_digest_auth_success
-    @agent.basic_auth('user', 'pass')
-    page = @agent.get("http://localhost/digest_auth")
-    assert_equal('You are authenticated', page.body)
-  end
-
-  def test_no_duplicate_headers
-    block_called = false
-    @agent.pre_connect_hooks << lambda { |params|
-      block_called = true
-      params[:request].to_hash.each do |k,v|
-        assert_equal(1, v.length)
-      end
-    }
-    @agent.basic_auth('user', 'pass')
-    page = @agent.get("http://localhost/digest_auth")
-    assert block_called
-  end
-
-  def test_post_auth_success
-    class << @agent
-      alias :old_fetch_page :fetch_page
-      attr_accessor :requests
-      def fetch_page(args)
-        @requests ||= []
-        x = old_fetch_page(args)
-        @requests << args[:verb]
-        x
-      end
-    end
-    @agent.basic_auth('user', 'pass')
-    page = @agent.post("http://localhost/basic_auth")
-    assert_equal('You are authenticated', page.body)
-    assert_equal(2, @agent.requests.length)
-    r1 = @agent.requests[0]
-    r2 = @agent.requests[1]
-    assert_equal(r1, r2)
-  end
-
-  def test_auth_bad_user_pass
-    @agent.basic_auth('aaron', 'aaron')
-    begin
-      page = @agent.get("http://localhost/basic_auth")
-    rescue Mechanize::ResponseCodeError => e
-      assert_equal("401", e.response_code)
-    end
-  end
-
-  def test_auth_failure
-    begin
-      page = @agent.get("http://localhost/basic_auth")
-    rescue Mechanize::ResponseCodeError => e
-      assert_equal("401", e.response_code)
-    end
-  end
-
-end

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

@@ -1,25 +0,0 @@
-require "helper"
-
-class TestBadLinks < Test::Unit::TestCase
-  def setup
-    @agent = Mechanize.new
-    @page = @agent.get("http://localhost/tc_bad_links.html")
-  end
-
-  def test_space_in_link
-    assert_nothing_raised do
-      @agent.click @page.links.first
-    end
-    assert_match(/alt_text.html$/, @agent.history.last.uri.to_s)
-    assert_equal(2, @agent.history.length)
-  end
-
-  def test_space_in_url
-    page = nil
-    assert_nothing_raised do
-      page = @agent.get("http://localhost/tc_bad_links.html ")
-    end
-    assert_match(/tc_bad_links.html$/, @agent.history.last.uri.to_s)
-    assert_equal(2, @agent.history.length)
-  end
-end

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

@@ -1,16 +0,0 @@
-require "helper"
-
-class BlankFormTest < Test::Unit::TestCase
-  def setup
-    @agent = Mechanize.new
-  end
-
-  def test_blank_form_query_string
-    page = @agent.get('http://localhost/tc_blank_form.html')
-    form = page.forms.first
-    query = form.build_query
-    assert(query.length > 0)
-    assert query.all? { |x| x[1] == '' }
-  end
-end
-

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

@@ -1,61 +0,0 @@
-require "helper"
-
-class TestCheckBoxes < Test::Unit::TestCase
-  def setup
-    @agent = Mechanize.new
-    @page = @agent.get('http://localhost/tc_checkboxes.html')
-  end
-
-  def test_select_one
-    form = @page.forms.first
-    form.checkbox_with(:name => 'green').check
-    assert(form.checkbox_with(:name => 'green').checked)
-    %w{ red blue yellow brown }.each do |color|
-      assert_equal(false, form.checkbox_with(:name => color).checked)
-    end
-  end
-
-  def test_select_all
-    form = @page.forms.first
-    form.checkboxes.each do |b|
-      b.check
-    end
-    form.checkboxes.each do |b|
-      assert_equal(true, b.checked)
-    end
-  end
-
-  def test_select_none
-    form = @page.forms.first
-    form.checkboxes.each do |b|
-      b.uncheck
-    end
-    form.checkboxes.each do |b|
-      assert_equal(false, b.checked)
-    end
-  end
-
-  def test_check_one
-    form = @page.forms.first
-    assert_equal(2, form.checkboxes_with(:name => 'green').length)
-    form.checkboxes_with(:name => 'green')[1].check
-    assert_equal(false,  form.checkboxes_with(:name => 'green')[0].checked)
-    assert_equal(true,  form.checkboxes_with(:name => 'green')[1].checked)
-    page = @agent.submit(form)
-    assert_equal(1, page.links.length)
-    assert_equal('green:on', page.links.first.text)
-  end
-
-  def test_check_two
-    form = @page.forms.first
-    assert_equal(2, form.checkboxes_with(:name => 'green').length)
-    form.checkboxes_with(:name => 'green')[0].check
-    form.checkboxes_with(:name => 'green')[1].check
-    assert_equal(true,  form.checkboxes_with(:name => 'green')[0].checked)
-    assert_equal(true,  form.checkboxes_with(:name => 'green')[1].checked)
-    page = @agent.submit(form)
-    assert_equal(2, page.links.length)
-    assert_equal('green:on', page.links.first.text)
-    assert_equal('green:on', page.links[1].text)
-  end
-end

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

@@ -1,13 +0,0 @@
-require "helper"
-
-class TestContentType < Test::Unit::TestCase
-  def setup
-    @agent = Mechanize.new
-  end
-
-  def test_application_xhtml_xml
-    url = 'http://localhost/content_type_test?ct=application/xhtml%2Bxml'
-    page = @agent.get url
-    assert_equal Mechanize::Page, page.class, "xhtml docs should return a Page"
-  end
-end

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

@@ -1,338 +0,0 @@
-require "helper"
-
-module Enumerable
-  def combine
-    masks = inject([[], 1]){|(ar, m), e| [ar << m, m << 1 ] }[0]
-    all = masks.inject(0){ |al, m| al|m }
-
-    result = []
-    for i in 1..all do
-      tmp = []
-      each_with_index do |e, idx|
-        tmp << e unless (masks[idx] & i) == 0
-      end
-      result << tmp
-    end
-    result
-  end
-end
-
-class CookieClassTest < Test::Unit::TestCase
-  def silently
-    warn_level = $VERBOSE
-    $VERBOSE = false
-    res = yield
-    $VERBOSE = warn_level
-    res
-  end
-
-  def test_parse_dates
-    url = URI.parse('http://localhost/')
-
-    yesterday = Time.now - 86400
-
-    dates = [ "14 Apr 89 03:20:12",
-              "14 Apr 89 03:20 GMT",
-              "Fri, 17 Mar 89 4:01:33",
-              "Fri, 17 Mar 89 4:01 GMT",
-              "Mon Jan 16 16:12 PDT 1989",
-              "Mon Jan 16 16:12 +0130 1989",
-              "6 May 1992 16:41-JST (Wednesday)",
-              #"22-AUG-1993 10:59:12.82",
-              "22-AUG-1993 10:59pm",
-              "22-AUG-1993 12:59am",
-              "22-AUG-1993 12:59 PM",
-              #"Friday, August 04, 1995 3:54 PM",
-              #"06/21/95 04:24:34 PM",
-              #"20/06/95 21:07",
-              "95-06-08 19:32:48 EDT",
-    ]
-
-    dates.each do |date|
-      cookie = "PREF=1; expires=#{date}"
-      silently do
-        Mechanize::Cookie.parse(url, cookie) { |c|
-          assert c.expires, "Tried parsing: #{date}"
-          assert_equal(true, c.expires < yesterday)
-        }
-      end
-    end
-  end
-
-  def test_parse_weird_cookie
-    cookie = 'n/a, ASPSESSIONIDCSRRQDQR=FBLDGHPBNDJCPCGNCPAENELB; path=/'
-    url = URI.parse('http://www.searchinnovation.com/')
-    Mechanize::Cookie.parse(url, cookie) { |c|
-      assert_equal('ASPSESSIONIDCSRRQDQR', c.name)
-      assert_equal('FBLDGHPBNDJCPCGNCPAENELB', c.value)
-    }
-  end
-
-  def test_double_semicolon
-    double_semi = 'WSIDC=WEST;; domain=.williams-sonoma.com; path=/'
-    url = URI.parse('http://williams-sonoma.com/')
-    Mechanize::Cookie.parse(url, double_semi) { |cookie|
-      assert_equal('WSIDC', cookie.name)
-      assert_equal('WEST', cookie.value)
-    }
-  end
-
-  def test_parse_bad_version
-    bad_cookie = 'PRETANET=TGIAqbFXtt; Name=/PRETANET; Path=/; Version=1.2; Content-type=text/html; Domain=192.168.6.196; expires=Friday, 13-November-2026  23:01:46 GMT;'
-    url = URI.parse('http://localhost/')
-    Mechanize::Cookie.parse(url, bad_cookie) { |cookie|
-      assert_nil(cookie.version)
-    }
-  end
-
-  def test_parse_bad_max_age
-    bad_cookie = 'PRETANET=TGIAqbFXtt; Name=/PRETANET; Path=/; Max-Age=1.2; Content-type=text/html; Domain=192.168.6.196; expires=Friday, 13-November-2026  23:01:46 GMT;'
-    url = URI.parse('http://localhost/')
-    Mechanize::Cookie.parse(url, bad_cookie) { |cookie|
-      assert_nil(cookie.max_age)
-    }
-  end
-
-  def test_parse_date_fail
-    url = URI.parse('http://localhost/')
-
-    dates = [ 
-              "20/06/95 21:07",
-    ]
-
-    silently do
-      dates.each do |date|
-        cookie = "PREF=1; expires=#{date}"
-        Mechanize::Cookie.parse(url, cookie) { |c|
-          assert_equal(true, c.expires.nil?)
-        }
-      end
-    end
-  end
-
-  def test_parse_valid_cookie
-    url = URI.parse('http://rubyforge.org/')
-    cookie_params = {}
-    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
-    cookie_params['path']      = 'path=/'
-    cookie_params['domain']    = 'domain=.rubyforge.org'
-    cookie_params['httponly']  = 'HttpOnly'
-    cookie_value = '12345%7D=ASDFWEE345%3DASda'
-
-    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
-    
-    cookie_params.keys.combine.each do |c|
-      cookie_text = "#{cookie_value}; "
-      c.each_with_index do |key, idx|
-        if idx == (c.length - 1)
-          cookie_text << "#{cookie_params[key]}"
-        else
-          cookie_text << "#{cookie_params[key]}; "
-        end
-      end
-      cookie = nil
-      Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
-      assert_not_nil(cookie)
-      assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
-      assert_equal('/', cookie.path)
-      assert_equal('rubyforge.org', cookie.domain)
-
-      # if expires was set, make sure we parsed it
-      if c.find { |k| k == 'expires' }
-        assert_equal(expires, cookie.expires)
-      else
-        assert_nil(cookie.expires)
-      end
-    end
-  end
-
-  def test_parse_valid_cookie_empty_value
-    url = URI.parse('http://rubyforge.org/')
-    cookie_params = {}
-    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
-    cookie_params['path']      = 'path=/'
-    cookie_params['domain']    = 'domain=.rubyforge.org'
-    cookie_params['httponly']  = 'HttpOnly'
-    cookie_value = '12345%7D='
-
-    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
-    
-    cookie_params.keys.combine.each do |c|
-      cookie_text = "#{cookie_value}; "
-      c.each_with_index do |key, idx|
-        if idx == (c.length - 1)
-          cookie_text << "#{cookie_params[key]}"
-        else
-          cookie_text << "#{cookie_params[key]}; "
-        end
-      end
-      cookie = nil
-      Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
-      assert_not_nil(cookie)
-      assert_equal('12345%7D=', cookie.to_s)
-      assert_equal('', cookie.value)
-      assert_equal('/', cookie.path)
-      assert_equal('rubyforge.org', cookie.domain)
-
-      # if expires was set, make sure we parsed it
-      if c.find { |k| k == 'expires' }
-        assert_equal(expires, cookie.expires)
-      else
-        assert_nil(cookie.expires)
-      end
-    end
-  end
-
-  # If no path was given, use the one from the URL
-  def test_cookie_using_url_path
-    url = URI.parse('http://rubyforge.org/login.php')
-    cookie_params = {}
-    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
-    cookie_params['path']      = 'path=/'
-    cookie_params['domain']    = 'domain=.rubyforge.org'
-    cookie_params['httponly']  = 'HttpOnly'
-    cookie_value = '12345%7D=ASDFWEE345%3DASda'
-
-    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
-    
-    cookie_params.keys.combine.each do |c|
-      next if c.find { |k| k == 'path' }
-      cookie_text = "#{cookie_value}; "
-      c.each_with_index do |key, idx|
-        if idx == (c.length - 1)
-          cookie_text << "#{cookie_params[key]}"
-        else
-          cookie_text << "#{cookie_params[key]}; "
-        end
-      end
-      cookie = nil
-      Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
-      assert_not_nil(cookie)
-      assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
-      assert_equal('rubyforge.org', cookie.domain)
-      assert_equal('/', cookie.path)
-
-      # if expires was set, make sure we parsed it
-      if c.find { |k| k == 'expires' }
-        assert_equal(expires, cookie.expires)
-      else
-        assert_nil(cookie.expires)
-      end
-    end
-  end
-
-  # Test using secure cookies
-  def test_cookie_with_secure
-    url = URI.parse('http://rubyforge.org/')
-    cookie_params = {}
-    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
-    cookie_params['path']      = 'path=/'
-    cookie_params['domain']    = 'domain=.rubyforge.org'
-    cookie_params['secure']    = 'secure'
-    cookie_value = '12345%7D=ASDFWEE345%3DASda'
-
-    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
-    
-    cookie_params.keys.combine.each do |c|
-      next unless c.find { |k| k == 'secure' }
-      cookie_text = "#{cookie_value}; "
-      c.each_with_index do |key, idx|
-        if idx == (c.length - 1)
-          cookie_text << "#{cookie_params[key]}"
-        else
-          cookie_text << "#{cookie_params[key]}; "
-        end
-      end
-      cookie = nil
-      Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
-      assert_not_nil(cookie)
-      assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
-      assert_equal('rubyforge.org', cookie.domain)
-      assert_equal('/', cookie.path)
-      assert_equal(true, cookie.secure)
-
-      # if expires was set, make sure we parsed it
-      if c.find { |k| k == 'expires' }
-        assert_equal(expires, cookie.expires)
-      else
-        assert_nil(cookie.expires)
-      end
-    end
-  end
-
-  # If no domain was given, we must use the one from the URL
-  def test_cookie_with_url_domain
-    url = URI.parse('http://login.rubyforge.org/')
-    cookie_params = {}
-    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
-    cookie_params['path']      = 'path=/'
-    cookie_params['domain']    = 'domain=.rubyforge.org'
-    cookie_params['httponly']  = 'HttpOnly'
-    cookie_value = '12345%7D=ASDFWEE345%3DASda'
-
-    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
-    
-    cookie_params.keys.combine.each do |c|
-      next if c.find { |k| k == 'domain' }
-      cookie_text = "#{cookie_value}; "
-      c.each_with_index do |key, idx|
-        if idx == (c.length - 1)
-          cookie_text << "#{cookie_params[key]}"
-        else
-          cookie_text << "#{cookie_params[key]}; "
-        end
-      end
-      cookie = nil
-      Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
-      assert_not_nil(cookie)
-      assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
-      assert_equal('/', cookie.path)
-
-      assert_equal('login.rubyforge.org', cookie.domain)
-
-      # if expires was set, make sure we parsed it
-      if c.find { |k| k == 'expires' }
-        assert_equal(expires, cookie.expires)
-      else
-        assert_nil(cookie.expires)
-      end
-    end
-  end
-
-  def test_parse_cookie_no_spaces
-    url = URI.parse('http://rubyforge.org/')
-    cookie_params = {}
-    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
-    cookie_params['path']      = 'path=/'
-    cookie_params['domain']    = 'domain=.rubyforge.org'
-    cookie_params['httponly']  = 'HttpOnly'
-    cookie_value = '12345%7D=ASDFWEE345%3DASda'
-
-    expires = Time.parse('Sun, 27-Sep-2037 00:00:00 GMT')
-    
-    cookie_params.keys.combine.each do |c|
-      cookie_text = "#{cookie_value};"
-      c.each_with_index do |key, idx|
-        if idx == (c.length - 1)
-          cookie_text << "#{cookie_params[key]}"
-        else
-          cookie_text << "#{cookie_params[key]};"
-        end
-      end
-      cookie = nil
-      Mechanize::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
-      assert_not_nil(cookie)
-      assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
-      assert_equal('/', cookie.path)
-      assert_equal('rubyforge.org', cookie.domain)
-
-      # if expires was set, make sure we parsed it
-      if c.find { |k| k == 'expires' }
-        assert_equal(expires, cookie.expires)
-      else
-        assert_nil(cookie.expires)
-      end
-    end
-  end
-end
-