eric-mechanize 0.9.3.20090623142847

data/test/test_cookie_jar.rb

@@ -0,0 +1,362 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class CookieJarTest < Test::Unit::TestCase
+  def cookie_from_hash(hash)
+    c = WWW::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
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => Time.now + (10 * 86400),
+                :domain   => 'rubyforge.org'
+             }
+
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::Mechanize::CookieJar.new
+    cookie = cookie_from_hash(values)
+    jar.add(url, cookie)
+    jar.add(url, cookie_from_hash(values.merge(: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
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => Time.now + (10 * 86400),
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::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_empty_value
+    values = {  :name     => 'Foo',
+                :value    => '',
+                :path     => '/',
+                :expires  => Time.now + (10 * 86400),
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::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
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => Time.now + (10 * 86400),
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::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 the same cookie, and we should still only have one
+    jar.add(url, cookie_from_hash(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
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => Time.now + (10 * 86400),
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::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 the same cookie, and we should still only have one
+    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)
+
+    # 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
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => Time.now + (10 * 86400),
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::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)
+    jar.add(url, cookie_from_hash(values.merge( :name => 'Baz' )))
+    assert_equal(2, jar.cookies(url).length)
+
+    jar.clear!
+
+    assert_equal(0, jar.cookies(url).length)
+  end
+
+  def test_save_cookies
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => Time.now + (10 * 86400),
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::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)
+    jar.add(url, cookie_from_hash(values.merge( :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
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => Time.now + (10 * 86400),
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::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)
+  end
+
+  def test_session_cookies
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => nil,
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::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 = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/login',
+                :expires  => nil,
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/login')
+
+    jar = WWW::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
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => Time.now + (10 * 86400),
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::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)
+    jar.add(url, cookie_from_hash(values.merge( :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_ssl_cookies
+    # thanks to michal "ocher" ochman for reporting the bug responsible for this test.
+    values = {  :name     => 'Foo',
+      :value    => 'Bar',
+      :path     => '/login',
+      :expires  => nil,
+      :domain   => 'rubyforge.org'
+    }
+    values_ssl = {  :name     => 'Foo',
+      :value    => 'Bar',
+      :path     => '/login',
+      :expires  => nil,
+      :domain   => 'rubyforge.org:443'
+    }
+    url = URI.parse('https://rubyforge.org/login')
+
+    jar = WWW::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/test/test_cookies.rb

@@ -0,0 +1,123 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class CookiesMechTest < Test::Unit::TestCase
+  def setup
+    @agent = WWW::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