domo 0.0.3 → 0.0.4

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

@@ -0,0 +1,324 @@
+require "helper"
+
+class CookieJarTest < Test::Unit::TestCase
+  def cookie_values(options = {})
+    {
+      :name     => 'Foo',
+      :value    => 'Bar',
+      :path     => '/',
+      :expires  => Time.now + (10 * 86400),
+      :domain   => 'rubyforge.org'
+   }.merge(options)
+  end
+
+  def cookie_from_hash(hash)
+    c = Mechanize::Cookie.new(hash[:name], hash[:value])
+    hash.each { |k,v|
+      next if k == :name || k == :value
+      c.send("#{k}=", v)
+    }
+    c
+  end
+
+  def test_two_cookies_same_domain_and_name_different_paths
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = Mechanize::CookieJar.new
+    cookie = cookie_from_hash(cookie_values)
+    jar.add(url, cookie)
+    jar.add(url, cookie_from_hash(cookie_values(:path => '/onetwo')))
+
+    assert_equal(1, jar.cookies(url).length)
+    assert_equal 2, jar.cookies(URI.parse('http://rubyforge.org/onetwo')).length
+  end
+
+  def test_domain_case
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = Mechanize::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = cookie_from_hash(cookie_values)
+    jar.add(url, cookie)
+    assert_equal(1, jar.cookies(url).length)
+
+    jar.add(url, cookie_from_hash(
+        cookie_values(:domain => 'RuByForge.Org', :name   => 'aaron')))
+
+    assert_equal(2, jar.cookies(url).length)
+
+    url2 = URI.parse('http://RuByFoRgE.oRg/')
+    assert_equal(2, jar.cookies(url2).length)
+  end
+
+  def test_empty_value
+    values = cookie_values(:value => "")
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = Mechanize::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = cookie_from_hash(values)
+    jar.add(url, cookie)
+    assert_equal(1, jar.cookies(url).length)
+
+    jar.add(url, cookie_from_hash( values.merge(  :domain => 'RuByForge.Org',
+                                                  :name   => 'aaron'
+                                               ) ) )
+
+    assert_equal(2, jar.cookies(url).length)
+
+    url2 = URI.parse('http://RuByFoRgE.oRg/')
+    assert_equal(2, jar.cookies(url2).length)
+  end
+
+  def test_add_future_cookies
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = Mechanize::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = cookie_from_hash(cookie_values)
+    jar.add(url, cookie)
+    assert_equal(1, jar.cookies(url).length)
+
+    # Add the same cookie, and we should still only have one
+    jar.add(url, cookie_from_hash(cookie_values))
+    assert_equal(1, jar.cookies(url).length)
+
+    # Make sure we can get the cookie from different paths
+    assert_equal(1, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
+
+    # Make sure we can't get the cookie from different domains
+    assert_equal(0, jar.cookies(URI.parse('http://google.com/')).length)
+  end
+
+  def test_add_multiple_cookies
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = Mechanize::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = cookie_from_hash(cookie_values)
+    jar.add(url, cookie)
+    assert_equal(1, jar.cookies(url).length)
+
+    # Add the same cookie, and we should still only have one
+    jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
+    assert_equal(2, jar.cookies(url).length)
+
+    # Make sure we can get the cookie from different paths
+    assert_equal(2, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
+
+    # Make sure we can't get the cookie from different domains
+    assert_equal(0, jar.cookies(URI.parse('http://google.com/')).length)
+  end
+
+  def test_clear_cookies
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = Mechanize::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = cookie_from_hash(cookie_values)
+    jar.add(url, cookie)
+    jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
+    assert_equal(2, jar.cookies(url).length)
+
+    jar.clear!
+
+    assert_equal(0, jar.cookies(url).length)
+  end
+
+  def test_save_cookies
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = Mechanize::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = cookie_from_hash(cookie_values)
+    jar.add(url, cookie)
+    jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
+    assert_equal(2, jar.cookies(url).length)
+
+    jar.save_as("cookies.yml")
+    jar.clear!
+    assert_equal(0, jar.cookies(url).length)
+
+    jar.load("cookies.yml")
+    assert_equal(2, jar.cookies(url).length)
+    FileUtils.rm("cookies.yml")
+  end
+
+  def test_expire_cookies
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = Mechanize::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = cookie_from_hash(cookie_values)
+    jar.add(url, cookie)
+    assert_equal(1, jar.cookies(url).length)
+
+    # Add a second cookie
+    jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
+    assert_equal(2, jar.cookies(url).length)
+
+    # Make sure we can get the cookie from different paths
+    assert_equal(2, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
+
+    # Expire the first cookie
+    jar.add(url, cookie_from_hash(
+        cookie_values(:expires => Time.now - (10 * 86400))))
+    assert_equal(1, jar.cookies(url).length)
+
+    # Expire the second cookie
+    jar.add(url, cookie_from_hash(
+        cookie_values( :name => 'Baz', :expires => Time.now - (10 * 86400))))
+    assert_equal(0, jar.cookies(url).length)
+  end
+
+  def test_session_cookies
+    values = cookie_values(:expires => nil)
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = Mechanize::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = cookie_from_hash(values)
+    jar.add(url, cookie)
+    assert_equal(1, jar.cookies(url).length)
+
+    # Add a second cookie
+    jar.add(url, cookie_from_hash(values.merge(:name => 'Baz')))
+    assert_equal(2, jar.cookies(url).length)
+
+    # Make sure we can get the cookie from different paths
+    assert_equal(2, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
+
+    # Expire the first cookie
+    jar.add(url, cookie_from_hash(values.merge(:expires => Time.now - (10 * 86400))))
+    assert_equal(1, jar.cookies(url).length)
+
+    # Expire the second cookie
+    jar.add(url, cookie_from_hash(
+        values.merge(:name => 'Baz', :expires => Time.now - (10 * 86400))))
+    assert_equal(0, jar.cookies(url).length)
+
+    # When given a URI with a blank path, CookieJar#cookies should return
+    # cookies with the path '/':
+    url = URI.parse('http://rubyforge.org')
+    assert_equal '', url.path
+    assert_equal(0, jar.cookies(url).length)
+    # Now add a cookie with the path set to '/':
+    jar.add(url, cookie_from_hash(values.merge( :name => 'has_root_path',
+                                          :path => '/')))
+    assert_equal(1, jar.cookies(url).length)
+  end
+
+  def test_paths
+    values = cookie_values(:path => "/login", :expires => nil)
+    url = URI.parse('http://rubyforge.org/login')
+
+    jar = Mechanize::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = cookie_from_hash(values)
+    jar.add(url, cookie)
+    assert_equal(1, jar.cookies(url).length)
+
+    # Add a second cookie
+    jar.add(url, cookie_from_hash(values.merge( :name => 'Baz' )))
+    assert_equal(2, jar.cookies(url).length)
+
+    # Make sure we don't get the cookie in a different path
+    assert_equal(0, jar.cookies(URI.parse('http://rubyforge.org/hello')).length)
+    assert_equal(0, jar.cookies(URI.parse('http://rubyforge.org/')).length)
+
+    # Expire the first cookie
+    jar.add(url, cookie_from_hash(values.merge( :expires => Time.now - (10 * 86400))))
+    assert_equal(1, jar.cookies(url).length)
+
+    # Expire the second cookie
+    jar.add(url, cookie_from_hash(values.merge( :name => 'Baz',
+                                          :expires => Time.now - (10 * 86400))))
+    assert_equal(0, jar.cookies(url).length)
+  end
+
+
+  def test_save_and_read_cookiestxt
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = Mechanize::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = cookie_from_hash(cookie_values)
+    jar.add(url, cookie)
+    jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
+    assert_equal(2, jar.cookies(url).length)
+
+    jar.save_as("cookies.txt", :cookiestxt)
+    jar.clear!
+    assert_equal(0, jar.cookies(url).length)
+
+    jar.load("cookies.txt", :cookiestxt)
+    assert_equal(2, jar.cookies(url).length)
+
+    FileUtils.rm("cookies.txt")
+  end
+
+  def test_save_and_read_cookiestxt_with_session_cookies
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = Mechanize::CookieJar.new
+
+    jar.add(url, cookie_from_hash(cookie_values(:expires => nil)))
+    jar.save_as("cookies.txt", :cookiestxt)
+    jar.clear!
+    assert_equal(0, jar.cookies(url).length)
+
+    jar.load("cookies.txt", :cookiestxt)
+    assert_equal(1, jar.cookies(url).length)
+    assert_nil jar.cookies(url).first.expires
+    FileUtils.rm("cookies.txt")
+  end
+
+  def test_save_and_read_expired_cookies
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = Mechanize::CookieJar.new
+    jar.jar['rubyforge.org'] = {}
+
+    assert_nothing_raised do
+      jar.add(url, cookie_from_hash(cookie_values))
+    end
+  end
+
+  def test_ssl_cookies
+    # thanks to michal "ocher" ochman for reporting the bug responsible for this test.
+    values = cookie_values(:expires => nil)
+    values_ssl = values.merge(:domain => "#{values[:domain]}:443")
+    url = URI.parse('https://rubyforge.org/login')
+
+    jar = Mechanize::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    cookie = cookie_from_hash(values)
+    jar.add(url, cookie)
+    assert_equal(1, jar.cookies(url).length, "did not handle SSL cookie")
+
+    cookie = cookie_from_hash(values_ssl)
+    jar.add(url, cookie)
+    assert_equal(2, jar.cookies(url).length, "did not handle SSL cookie with :443")
+  end
+end

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

@@ -0,0 +1,123 @@
+require "helper"
+
+class CookiesMechTest < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+  end
+
+  def test_meta_tag_cookies
+    cookies = @agent.cookies.length
+    page = @agent.get("http://localhost/meta_cookie.html")
+    assert_equal(cookies + 1, @agent.cookies.length)
+  end
+
+  def test_send_cookies
+    page = @agent.get("http://localhost/many_cookies")
+    page = @agent.get("http://localhost/send_cookies")
+    assert_equal(3, page.links.length)
+    assert_not_nil(page.links.find { |l| l.text == "name:Aaron" })
+    assert_not_nil(page.links.find { |l| l.text == "no_expires:nope" })
+  end
+
+  def test_no_space_cookies
+    page = @agent.get("http://localhost/one_cookie_no_space")
+    assert_equal(1, @agent.cookies.length)
+    foo_cookie = @agent.cookies.find { |k| k.name == 'foo' }
+    assert_not_nil(foo_cookie, 'Foo cookie was nil')
+    assert_equal('bar', foo_cookie.value)
+    assert_equal('/', foo_cookie.path)
+    assert_equal(true, Time.now < foo_cookie.expires)
+  end
+
+  def test_many_cookies_as_string
+    page = @agent.get("http://localhost/many_cookies_as_string")
+    assert_equal(4, @agent.cookies.length)
+
+    name_cookie = @agent.cookies.find { |k| k.name == "name" }
+    assert_not_nil(name_cookie, "Name cookie was nil")
+    assert_equal("Aaron", name_cookie.value)
+    assert_equal("/", name_cookie.path)
+    assert_equal(true, Time.now < name_cookie.expires)
+
+    expired_cookie = @agent.cookies.find { |k| k.name == "expired" }
+    assert_nil(expired_cookie, "Expired cookie was not nil")
+
+    no_exp_cookie = @agent.cookies.find { |k| k.name == "no_expires" }
+    assert_not_nil(no_exp_cookie, "No expires cookie is nil")
+    assert_equal("nope", no_exp_cookie.value)
+    assert_equal("/", no_exp_cookie.path)
+    assert_nil(no_exp_cookie.expires)
+
+    path_cookie = @agent.cookies.find { |k| k.name == "a_path" }
+    assert_not_nil(path_cookie, "Path cookie is nil")
+    assert_equal("some_path", path_cookie.value)
+    assert_equal(true, Time.now < path_cookie.expires)
+
+    no_path_cookie = @agent.cookies.find { |k| k.name == "no_path" }
+    assert_not_nil(no_path_cookie, "No path cookie is nil")
+    assert_equal("no_path", no_path_cookie.value)
+    assert_equal("/", no_path_cookie.path)
+    assert_equal(true, Time.now < no_path_cookie.expires)
+  end
+
+  def test_many_cookies
+    page = @agent.get("http://localhost/many_cookies")
+    assert_equal(4, @agent.cookies.length)
+
+    name_cookie = @agent.cookies.find { |k| k.name == "name" }
+    assert_not_nil(name_cookie, "Name cookie was nil")
+    assert_equal("Aaron", name_cookie.value)
+    assert_equal("/", name_cookie.path)
+    assert_equal(true, Time.now < name_cookie.expires)
+
+    expired_cookie = @agent.cookies.find { |k| k.name == "expired" }
+    assert_nil(expired_cookie, "Expired cookie was not nil")
+
+    no_exp_cookie = @agent.cookies.find { |k| k.name == "no_expires" }
+    assert_not_nil(no_exp_cookie, "No expires cookie is nil")
+    assert_equal("nope", no_exp_cookie.value)
+    assert_equal("/", no_exp_cookie.path)
+    assert_nil(no_exp_cookie.expires)
+
+    path_cookie = @agent.cookies.find { |k| k.name == "a_path" }
+    assert_not_nil(path_cookie, "Path cookie is nil")
+    assert_equal("some_path", path_cookie.value)
+    assert_equal(true, Time.now < path_cookie.expires)
+
+    no_path_cookie = @agent.cookies.find { |k| k.name == "no_path" }
+    assert_not_nil(no_path_cookie, "No path cookie is nil")
+    assert_equal("no_path", no_path_cookie.value)
+    assert_equal("/", no_path_cookie.path)
+    assert_equal(true, Time.now < no_path_cookie.expires)
+  end
+
+  def test_get_cookie
+    assert_equal(true,
+      @agent.cookie_jar.empty?(
+      URI::parse("http://localhost/one_cookie")))
+
+    assert_equal(0, @agent.cookies.length)
+
+    page = @agent.get("http://localhost/one_cookie")
+    assert_equal(1, @agent.cookies.length)
+
+    cookie = @agent.cookies.first
+    assert_equal("foo", cookie.name)
+    assert_equal("bar", cookie.value)
+    assert_equal("/", cookie.path)
+    assert_equal("localhost", cookie.domain)
+
+    assert_equal(false,
+      @agent.cookie_jar.empty?(
+      URI::parse("http://localhost/one_cookie")))
+    page = @agent.get("http://localhost/one_cookie")
+
+    assert_equal(1, @agent.cookies.length)
+
+    cookie = @agent.cookies.first
+    assert_equal("foo", cookie.name)
+    assert_equal("bar", cookie.value)
+    assert_equal("/", cookie.path)
+    assert_equal("localhost", cookie.domain)
+  end
+end

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

@@ -0,0 +1,20 @@
+require "helper"
+
+class TestEncodedLinks < Test::Unit::TestCase
+  def setup
+    @agent = Mechanize.new
+    @page = @agent.get("http://localhost/tc_encoded_links.html")
+  end
+
+  def test_click_link
+    link = @page.links.first
+    assert_equal('/form_post?a=b&b=c', link.href)
+    page = @agent.click(link)
+    assert_equal("http://localhost/form_post?a=b&b=c", page.uri.to_s)
+  end
+
+  def test_hpricot_link
+    page = @agent.click(@page.search('a').first)
+    assert_equal("http://localhost/form_post?a=b&b=c", page.uri.to_s)
+  end
+end