diamond-mechanize 2.1 → 2.2

data/test/test_mechanize_cookie.rb

@@ -1,451 +0,0 @@
-require 'mechanize/test_case'
-
-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 TestMechanizeCookie < Mechanize::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_empty
-    cookie_str = 'a=b; ; c=d'
-
-    uri = URI.parse 'http://example'
-
-    Mechanize::Cookie.parse uri, cookie_str do |cookie|
-      assert_equal 'a', cookie.name
-      assert_equal 'b', cookie.value
-    end
-  end
-
-  def test_parse_no_space
-    cookie_str = "foo=bar;Expires=Sun, 06 Nov 2011 00:28:06 GMT;Path=/"
-
-    uri = URI.parse 'http://example'
-
-    Mechanize::Cookie.parse uri, cookie_str do |cookie|
-      assert_equal 'foo',               cookie.name
-      assert_equal 'bar',               cookie.value
-      assert_equal '/',                 cookie.path
-      assert_equal Time.at(1320539286), cookie.expires
-    end
-  end
-
-  def test_parse_quoted
-    cookie_str =
-      "quoted=\"value\"; Expires=Sun, 06 Nov 2011 00:11:18 GMT; Path=/"
-
-    uri = URI.parse 'http://example'
-
-    Mechanize::Cookie.parse uri, cookie_str do |cookie|
-      assert_equal 'quoted', cookie.name
-      assert_equal '"value"', cookie.value
-    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_domain_dot
-    url = URI.parse('http://host.example.com/')
-
-    cookie_str = 'a=b; domain=.example.com'
-
-    cookie = Mechanize::Cookie.parse(url, cookie_str).first
-
-    assert_equal 'example.com', cookie.domain
-    assert cookie.for_domain?
-  end
-
-  def test_parse_domain_no_dot
-    url = URI.parse('http://host.example.com/')
-
-    cookie_str = 'a=b; domain=example.com'
-
-    cookie = Mechanize::Cookie.parse(url, cookie_str).first
-
-    assert_equal 'example.com', cookie.domain
-    assert cookie.for_domain?
-  end
-
-  def test_parse_domain_none
-    url = URI.parse('http://example.com/')
-
-    cookie_str = 'a=b;'
-
-    cookie = Mechanize::Cookie.parse(url, cookie_str).first
-
-    assert_equal 'example.com', cookie.domain
-    assert !cookie.for_domain?
-  end
-
-  def test_parse_expires_session
-    cookie = 'PRETANET=TGIAqbFXtt; Name=/PRETANET; Path=/; Max-Age=1.2; Content-type=text/html; Domain=192.168.6.196; expires=;'
-
-    url = URI.parse('http://localhost/')
-
-    cookie = Mechanize::Cookie.parse(url, cookie).first
-
-    assert cookie.session
-  end
-
-  def test_parse_many
-    url = URI 'http://example/'
-    cookie_str =
-      "name=Aaron; Domain=localhost; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/, " \
-      "name=Aaron; Domain=localhost; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/, " \
-      "name=Aaron; Domain=localhost; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/, " \
-      "name=Aaron; Domain=localhost; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/; HttpOnly, " \
-      "expired=doh; Expires=Fri, 04 Nov 2011 00:29:51 GMT; Path=/, " \
-      "a_path=some_path; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/some_path, " \
-      "no_path=no_path; Expires=Sun, 06 Nov 2011 00:29:51 GMT, no_expires=nope; Path=/"
-
-    cookies = Mechanize::Cookie.parse url, cookie_str
-    assert_equal 8, cookies.length
-
-    name = cookies.find { |c| c.name == 'name' }
-    assert_equal "Aaron",             name.value
-    assert_equal "/",                 name.path
-    assert_equal Time.at(1320539391), name.expires
-
-    a_path = cookies.find { |c| c.name == 'a_path' }
-    assert_equal "some_path",         a_path.value
-    assert_equal "/some_path",        a_path.path
-    assert_equal Time.at(1320539391), a_path.expires
-
-    no_expires = cookies.find { |c| c.name == 'no_expires' }
-    assert_equal "nope", no_expires.value
-    assert_equal "/",    no_expires.path
-    assert_nil           no_expires.expires
-
-    no_path = cookies.find { |c| c.name == 'no_path' }
-    assert_equal "no_path",           no_path.value
-    assert_equal "/",                 no_path.path
-    assert_equal Time.at(1320539391), no_path.expires
-
-    assert cookies.find { |c| c.name == 'expired' }
-  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_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
-      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
-
-  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_equal('12345%7D=', cookie.to_s)
-      assert_equal('', cookie.value)
-      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
-
-  # 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_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
-      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_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
-      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
-
-  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_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
-      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
-
-  def test_new
-    cookie = Mechanize::Cookie.new('key', 'value')
-    assert_equal 'key', cookie.name
-    assert_equal 'value', cookie.value
-    assert_equal nil, cookie.expires
-
-    # Minimum unit for the expires attribute is second
-    expires = Time.at((Time.now + 3600).to_i)
-
-    cookie = Mechanize::Cookie.new('key', 'value', :expires => expires.dup)
-    assert_equal 'key', cookie.name
-    assert_equal 'value', cookie.value
-    assert_equal expires, cookie.expires
-
-    cookie = Mechanize::Cookie.new(:value => 'value', :name => 'key', :expires => expires.dup)
-    assert_equal 'key', cookie.name
-    assert_equal 'value', cookie.value
-    assert_equal expires, cookie.expires
-  end
-
-  def test_domain=
-    url = URI.parse('http://host.dom.example.com:8080/')
-
-    cookie_str = 'a=b; domain=Example.Com'
-    cookie = Mechanize::Cookie.parse(url, cookie_str).first
-    assert 'example.com', cookie.domain
-
-    cookie.domain = DomainName(url.host)
-    assert 'host.dom.example.com', cookie.domain
-
-    cookie.domain = 'Dom.example.com'
-    assert 'dom.example.com', cookie.domain
-
-    cookie.domain = Object.new.tap { |o|
-      def o.to_str
-        'Example.com'
-      end
-    }
-    assert 'example.com', cookie.domain
-  end
-end
-

data/test/test_mechanize_cookie_jar.rb

@@ -1,483 +0,0 @@
-require 'mechanize/test_case'
-
-class TestMechanizeCookieJar < Mechanize::TestCase
-
-  def setup
-    super
-
-    @jar = Mechanize::CookieJar.new
-  end
-
-  def cookie_values(options = {})
-    {
-      :name     => 'Foo',
-      :value    => 'Bar',
-      :path     => '/',
-      :expires  => Time.now + (10 * 86400),
-      :for_domain => true,
-      :domain   => 'rubyforge.org'
-   }.merge(options)
-  end
-
-  def test_two_cookies_same_domain_and_name_different_paths
-    url = URI 'http://rubyforge.org/'
-
-    cookie = Mechanize::Cookie.new(cookie_values)
-    @jar.add(url, cookie)
-    @jar.add(url, Mechanize::Cookie.new(cookie_values(:path => '/onetwo')))
-
-    assert_equal(1, @jar.cookies(url).length)
-    assert_equal 2, @jar.cookies(URI('http://rubyforge.org/onetwo')).length
-  end
-
-  def test_domain_case
-    url = URI 'http://rubyforge.org/'
-
-    # Add one cookie with an expiration date in the future
-    cookie = Mechanize::Cookie.new(cookie_values)
-    @jar.add(url, cookie)
-    assert_equal(1, @jar.cookies(url).length)
-
-    @jar.add(url, Mechanize::Cookie.new(
-        cookie_values(:domain => 'RuByForge.Org', :name   => 'aaron')))
-
-    assert_equal(2, @jar.cookies(url).length)
-
-    url2 = URI 'http://RuByFoRgE.oRg/'
-    assert_equal(2, @jar.cookies(url2).length)
-  end
-
-  def test_host_only
-    url = URI.parse('http://rubyforge.org/')
-
-    @jar.add(url, Mechanize::Cookie.new(
-        cookie_values(:domain => 'rubyforge.org', :for_domain => false)))
-
-    assert_equal(1, @jar.cookies(url).length)
-
-    assert_equal(1, @jar.cookies(URI('http://RubyForge.org/')).length)
-
-    assert_equal(1, @jar.cookies(URI('https://RubyForge.org/')).length)
-
-    assert_equal(0, @jar.cookies(URI('http://www.rubyforge.org/')).length)
-  end
-
-  def test_empty_value
-    values = cookie_values(:value => "")
-    url = URI 'http://rubyforge.org/'
-
-    # Add one cookie with an expiration date in the future
-    cookie = Mechanize::Cookie.new(values)
-    @jar.add(url, cookie)
-    assert_equal(1, @jar.cookies(url).length)
-
-    @jar.add url, Mechanize::Cookie.new(values.merge(:domain => 'RuByForge.Org',
-                                                     :name   => 'aaron'))
-
-    assert_equal(2, @jar.cookies(url).length)
-
-    url2 = URI 'http://RuByFoRgE.oRg/'
-    assert_equal(2, @jar.cookies(url2).length)
-  end
-
-  def test_add_future_cookies
-    url = URI 'http://rubyforge.org/'
-
-    # Add one cookie with an expiration date in the future
-    cookie = Mechanize::Cookie.new(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, Mechanize::Cookie.new(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('http://rubyforge.org/login')).length)
-
-    # Make sure we can't get the cookie from different domains
-    assert_equal(0, @jar.cookies(URI('http://google.com/')).length)
-  end
-
-  def test_add_multiple_cookies
-    url = URI 'http://rubyforge.org/'
-
-    # Add one cookie with an expiration date in the future
-    cookie = Mechanize::Cookie.new(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, Mechanize::Cookie.new(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('http://rubyforge.org/login')).length)
-
-    # Make sure we can't get the cookie from different domains
-    assert_equal(0, @jar.cookies(URI('http://google.com/')).length)
-  end
-
-  def test_add_rejects_cookies_that_do_not_contain_an_embedded_dot
-    url = URI 'http://rubyforge.org/'
-
-    tld_cookie = Mechanize::Cookie.new(cookie_values(:domain => '.org'))
-    @jar.add(url, tld_cookie)
-    single_dot_cookie = Mechanize::Cookie.new(cookie_values(:domain => '.'))
-    @jar.add(url, single_dot_cookie)
-
-    assert_equal(0, @jar.cookies(url).length)
-  end
-
-  def test_fall_back_rules_for_local_domains
-    url = URI 'http://www.example.local'
-
-    tld_cookie = Mechanize::Cookie.new(cookie_values(:domain => '.local'))
-    @jar.add(url, tld_cookie)
-
-    assert_equal(0, @jar.cookies(url).length)
-
-    sld_cookie = Mechanize::Cookie.new(cookie_values(:domain => '.example.local'))
-    @jar.add(url, sld_cookie)
-
-    assert_equal(1, @jar.cookies(url).length)
-  end
-
-  def test_add_makes_exception_for_localhost
-    url = URI 'http://localhost'
-
-    tld_cookie = Mechanize::Cookie.new(cookie_values(:domain => 'localhost'))
-    @jar.add(url, tld_cookie)
-
-    assert_equal(1, @jar.cookies(url).length)
-  end
-
-  def test_add_cookie_for_the_parent_domain
-    url = URI 'http://x.foo.com'
-
-    cookie = Mechanize::Cookie.new(cookie_values(:domain => '.foo.com'))
-    @jar.add(url, cookie)
-
-    assert_equal(1, @jar.cookies(url).length)
-  end
-
-  def test_add_does_not_reject_cookies_from_a_nested_subdomain
-    url = URI 'http://y.x.foo.com'
-
-    cookie = Mechanize::Cookie.new(cookie_values(:domain => '.foo.com'))
-    @jar.add(url, cookie)
-
-    assert_equal(1, @jar.cookies(url).length)
-  end
-
-  def test_cookie_without_leading_dot_does_not_cause_substring_match
-    url = URI 'http://arubyforge.org/'
-
-    cookie = Mechanize::Cookie.new(cookie_values(:domain => 'rubyforge.org'))
-    @jar.add(url, cookie)
-
-    assert_equal(0, @jar.cookies(url).length)
-  end
-
-  def test_cookie_without_leading_dot_matches_subdomains
-    url = URI 'http://admin.rubyforge.org/'
-
-    cookie = Mechanize::Cookie.new(cookie_values(:domain => 'rubyforge.org'))
-    @jar.add(url, cookie)
-
-    assert_equal(1, @jar.cookies(url).length)
-  end
-
-  def test_cookies_with_leading_dot_match_subdomains
-    url = URI 'http://admin.rubyforge.org/'
-
-    @jar.add(url, Mechanize::Cookie.new(cookie_values(:domain => '.rubyforge.org')))
-
-    assert_equal(1, @jar.cookies(url).length)
-  end
-
-  def test_cookies_with_leading_dot_match_parent_domains
-    url = URI 'http://rubyforge.org/'
-
-    @jar.add(url, Mechanize::Cookie.new(cookie_values(:domain => '.rubyforge.org')))
-
-    assert_equal(1, @jar.cookies(url).length)
-  end
-
-  def test_cookies_with_leading_dot_match_parent_domains_exactly
-    url = URI 'http://arubyforge.org/'
-
-    @jar.add(url, Mechanize::Cookie.new(cookie_values(:domain => '.rubyforge.org')))
-
-    assert_equal(0, @jar.cookies(url).length)
-  end
-
-  def test_cookie_for_ipv4_address_matches_the_exact_ipaddress
-    url = URI 'http://192.168.0.1/'
-
-    cookie = Mechanize::Cookie.new(cookie_values(:domain => '192.168.0.1'))
-    @jar.add(url, cookie)
-
-    assert_equal(1, @jar.cookies(url).length)
-  end
-
-  def test_cookie_for_ipv4_address_does_not_cause_subdomain_match
-    url = URI 'http://192.168.0.1/'
-
-    cookie = Mechanize::Cookie.new(cookie_values(:domain => '.0.1'))
-    @jar.add(url, cookie)
-
-    assert_equal(0, @jar.cookies(url).length)
-  end
-
-  def test_cookie_for_ipv6_address_matches_the_exact_ipaddress
-    url = URI 'http://[fe80::0123:4567:89ab:cdef]/'
-
-    cookie = Mechanize::Cookie.new(cookie_values(:domain => '[fe80::0123:4567:89ab:cdef]'))
-    @jar.add(url, cookie)
-
-    assert_equal(1, @jar.cookies(url).length)
-  end
-
-  def test_cookies_dot
-    url = URI 'http://www.host.example/'
-
-    @jar.add(url,
-             Mechanize::Cookie.new(cookie_values(:domain => 'www.host.example')))
-
-    url = URI 'http://wwwxhost.example/'
-    assert_equal(0, @jar.cookies(url).length)
-  end
-
-  def test_clear_bang
-    url = URI 'http://rubyforge.org/'
-
-    # Add one cookie with an expiration date in the future
-    cookie = Mechanize::Cookie.new(cookie_values)
-    @jar.add(url, cookie)
-    @jar.add(url, Mechanize::Cookie.new(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_yaml
-    url = URI 'http://rubyforge.org/'
-
-    # Add one cookie with an expiration date in the future
-    cookie = Mechanize::Cookie.new(cookie_values)
-    s_cookie = Mechanize::Cookie.new(cookie_values(:name => 'Bar',
-                                              :expires => nil,
-                                              :session => true))
-
-    @jar.add(url, cookie)
-    @jar.add(url, s_cookie)
-    @jar.add(url, Mechanize::Cookie.new(cookie_values(:name => 'Baz')))
-
-    assert_equal(3, @jar.cookies(url).length)
-
-    in_tmpdir do
-      @jar.save_as("cookies.yml")
-
-      jar = Mechanize::CookieJar.new
-      jar.load("cookies.yml")
-      assert_equal(2, jar.cookies(url).length)
-    end
-
-    assert_equal(3, @jar.cookies(url).length)
-  end
-
-  def test_save_cookies_cookiestxt
-    url = URI 'http://rubyforge.org/'
-
-    # Add one cookie with an expiration date in the future
-    cookie = Mechanize::Cookie.new(cookie_values)
-    s_cookie = Mechanize::Cookie.new(cookie_values(:name => 'Bar',
-                                              :expires => nil,
-                                              :session => true))
-
-    @jar.add(url, cookie)
-    @jar.add(url, s_cookie)
-    @jar.add(url, Mechanize::Cookie.new(cookie_values(:name => 'Baz')))
-
-    assert_equal(3, @jar.cookies(url).length)
-
-    in_tmpdir do
-      @jar.save_as("cookies.txt", :cookiestxt)
-
-      jar = Mechanize::CookieJar.new
-      jar.load("cookies.txt", :cookiestxt) # HACK test the format
-      assert_equal(2, jar.cookies(url).length)
-    end
-
-    assert_equal(3, @jar.cookies(url).length)
-  end
-
-  def test_expire_cookies
-    url = URI 'http://rubyforge.org/'
-
-    # Add one cookie with an expiration date in the future
-    cookie = Mechanize::Cookie.new(cookie_values)
-    @jar.add(url, cookie)
-    assert_equal(1, @jar.cookies(url).length)
-
-    # Add a second cookie
-    @jar.add(url, Mechanize::Cookie.new(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('http://rubyforge.org/login')).length)
-
-    # Expire the first cookie
-    @jar.add(url, Mechanize::Cookie.new(
-        cookie_values(:expires => Time.now - (10 * 86400))))
-    assert_equal(1, @jar.cookies(url).length)
-
-    # Expire the second cookie
-    @jar.add(url, Mechanize::Cookie.new(
-        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 'http://rubyforge.org/'
-
-    # Add one cookie with an expiration date in the future
-    cookie = Mechanize::Cookie.new(values)
-    @jar.add(url, cookie)
-    assert_equal(1, @jar.cookies(url).length)
-
-    # Add a second cookie
-    @jar.add(url, Mechanize::Cookie.new(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('http://rubyforge.org/login')).length)
-
-    # Expire the first cookie
-    @jar.add(url, Mechanize::Cookie.new(values.merge(:expires => Time.now - (10 * 86400))))
-    assert_equal(1, @jar.cookies(url).length)
-
-    # Expire the second cookie
-    @jar.add(url, Mechanize::Cookie.new(
-        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 '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, Mechanize::Cookie.new(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 'http://rubyforge.org/login'
-
-    # Add one cookie with an expiration date in the future
-    cookie = Mechanize::Cookie.new(values)
-    @jar.add(url, cookie)
-    assert_equal(1, @jar.cookies(url).length)
-
-    # Add a second cookie
-    @jar.add(url, Mechanize::Cookie.new(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('http://rubyforge.org/hello')).length)
-    assert_equal(0, @jar.cookies(URI('http://rubyforge.org/')).length)
-
-    # Expire the first cookie
-    @jar.add(url, Mechanize::Cookie.new(values.merge( :expires => Time.now - (10 * 86400))))
-    assert_equal(1, @jar.cookies(url).length)
-
-    # Expire the second cookie
-    @jar.add(url, Mechanize::Cookie.new(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 'http://rubyforge.org/'
-
-    # Add one cookie with an expiration date in the future
-    cookie = Mechanize::Cookie.new(cookie_values)
-    @jar.add(url, cookie)
-    @jar.add(url, Mechanize::Cookie.new(cookie_values(:name => 'Baz')))
-    assert_equal(2, @jar.cookies(url).length)
-
-    in_tmpdir do
-      @jar.save_as("cookies.txt", :cookiestxt)
-      @jar.clear!
-
-      @jar.load("cookies.txt", :cookiestxt)
-    end
-
-    assert_equal(2, @jar.cookies(url).length)
-  end
-
-  def test_save_and_read_cookiestxt_with_session_cookies
-    url = URI 'http://rubyforge.org/'
-
-    @jar.add(url, Mechanize::Cookie.new(cookie_values(:expires => nil)))
-
-    in_tmpdir do
-      @jar.save_as("cookies.txt", :cookiestxt)
-      @jar.clear!
-
-      @jar.load("cookies.txt", :cookiestxt)
-    end
-
-    assert_equal(1, @jar.cookies(url).length)
-    assert_nil @jar.cookies(url).first.expires
-  end
-
-  def test_save_and_read_expired_cookies
-    url = URI 'http://rubyforge.org/'
-
-    @jar.jar['rubyforge.org'] = {}
-
-
-    @jar.add url, Mechanize::Cookie.new(cookie_values)
-
-    # HACK no asertion
-  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(:name => 'Baz', :domain => "#{values[:domain]}:443")
-    url = URI 'https://rubyforge.org/login'
-
-    cookie = Mechanize::Cookie.new(values)
-    @jar.add(url, cookie)
-    assert_equal(1, @jar.cookies(url).length, "did not handle SSL cookie")
-
-    cookie = Mechanize::Cookie.new(values_ssl)
-    @jar.add(url, cookie)
-    assert_equal(2, @jar.cookies(url).length, "did not handle SSL cookie with :443")
-  end
-
-  def test_secure_cookie
-    nurl = URI 'http://rubyforge.org/login'
-    surl = URI 'https://rubyforge.org/login'
-
-    ncookie = Mechanize::Cookie.new(cookie_values(:name => 'Foo1'))
-    scookie = Mechanize::Cookie.new(cookie_values(:name => 'Foo2', :secure => true))
-
-    @jar.add(nurl, ncookie)
-    @jar.add(nurl, scookie)
-    @jar.add(surl, ncookie)
-    @jar.add(surl, scookie)
-
-    assert_equal('Foo1',      @jar.cookies(nurl).map { |c| c.name }.sort.join(' ') )
-    assert_equal('Foo1 Foo2', @jar.cookies(surl).map { |c| c.name }.sort.join(' ') )
-  end
-end